Forem: EugeneKwaka

How To Handle WebElements In Selenium Python

EugeneKwaka — Wed, 12 Apr 2023 05:30:41 +0000

Selenium automation testing is the common term used to describe a test run using Selenium. When it comes to automation testing, Selenium is a popular open-source testing tool used to automate different web browsers, such as Chrome, Firefox, Microsoft Edge, and Safari, among others, across multiple platforms. The Selenium WebDriver allows you to execute test scripts in various programming languages such as Java, Python, C#, JavaScript, PHP, and Ruby.

In Selenium, a WebElement represents an HTML element of a web page. WebElements are the building blocks of the web page. For example, anything on a web page, like a text box, button, links, dropdown buttons, etc., comes under WebElements.

Selenium WebDriver takes every single element and encapsulates it as an object of the WebElement. It provides an API to locate the web page elements and take a specific action like entering text into text boxes, clicking the buttons, etc. Using the Selenium framework, you can easily locate and interact with WebElements while performing Selenium Python testing.

Handling WebElements is important when automating web application testing. In this blog, we will look at how to handle WebElements in Selenium Python.

Automate Cypress testing and perform browser automation testing with LambdaTest. Our cloud infrastructure has 3000+ desktop & mobile environments. Try for free.

What are WebElements in Selenium?

WebElements in Selenium are HTML elements that make up the web page’s content. Each HTML document consists of several HTML elements. An HTML element comprises a start tag and an end tag determining its position in the document. Between those HTML tags lies the content of the document.

Syntax:


content comes here 
&lt;/end tag&gt;

The WebElement interface in Selenium allows you to interact with both visible and invisible elements on a web page. In Selenium, all the methods return a value or no value (null/void). Similarly, the WebElement command returns either null/void or the element being searched for.

Shown below is the command of a WebElement in Selenium:

 WebElement element = driver.findElement(By.id(“UserName“));

Subscribe to the LambdaTest YouTube Channel and get the latest tutorials around automation testing, Selenium testing, Playwright, Appium, and more.

Handling WebElements in Selenium Python

Selenium makes it simple for developers to automate web testing and help you handle WebElements in Selenium Python when performing Python automation testing. Here are some of the best approaches to handling WebElements in Selenium Python.

Alert Pop-Ups

Alerts and pop-ups are notification messages that alert a user about information or request authorization to carry out certain tasks. The appearance of an alert while performing Python web automation hinders the Selenium WebDriver from interacting with the webpage’s elements until the alert is dismissed. This leads to tests stalling or failing if the alerts or pop-ups are not handled.

When an alert is prompted, the alert pop-up window is displayed on the current webpage. Since the Selenium WebDriver’s context is on the current page, we need to switch the WebDriver’s focus to the new alert window.

This is done using the switch_to.alert() code command:

alert_object = driver.switch_to.alert

The other alert handling methods include:

accept()

alert_object = Alert(driver)
alert_object.accept()

dismiss()

The dismiss() method cancels the alert prompt.

alert_object = Alert(driver)
alert_object.dismiss()

send_keys()

The send_keys() method accepts an argument, which will be entered in the alert pop-up.

alert_object = Alert(driver)
alert_object.send_keys("Okay")

text()

The text() method retrieves and displays the text that is in the alert pop-up.

alert_object = Alert(driver)
print(alert_object.text)

Demonstration: How to handle an Alert in Selenium Python

Let us look at an example of a prompt alert and how we can handle it in Selenium Python.

Test Case:

To demonstrate how to handle an alert, we will use the example of the JavaScript Alert Box Demo from the LambdaTest Selenium Playground.

Go to the JavaScript Alert Box demo page.
Click on the Click Me button in the last JavaScript Alert Box page
Enter your name on the alert pop-up.
Click on the OK button.

Implementation (Test Case on the Chrome Browser):

Let us write a test script to handle a simple alert.

import os
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options as ChromeOptions


def test_handling_simple_alert():
    options = ChromeOptions()
    options.browser_version = "108.0"
    options.platform_name = "Windows 10"
    lt_options = {};
    lt_options["username"] = os.environ.get('LT_USERNAME');
    lt_options["accessKey"] = os.environ.get('LT_ACCESS_KEY');
    lt_options["build"] = "Handling Alerts";
    lt_options["project"] = "Handling Alerts";
    lt_options["name"] = "Handling Alerts";
    lt_options["w3c"] = True;
    lt_options["plugin"] = "python-python";
    options.set_capability('LT:Options', lt_options);

    # LambdaTest Profile username
    user_name = os.environ.get('LT_USERNAME')
    # LambdaTest Profile access_key
    accesskey = os.environ.get('LT_ACCESS_KEY')
    remote_url =  "https://" + user_name + ":" + accesskey + "@hub.lambdatest.com/wd/hub"
    driver = webdriver.Remote(remote_url, options=options)

    driver.get("https://www.lambdatest.com/selenium-playground/javascript-alert-box-demo")
    # Locate the button that prompts the alert
    alert_button = WebDriverWait(driver, 3).until(EC.element_to_be_clickable((By.XPATH, '//*[@id="__next"]/section[4]/div/div/div[2]/div[3]/p[3]/button')))
    alert_button.click()
    # Switch the webdriver's control to the alert pop-up
    alert_object = driver.switch_to.alert
    # Show the alert message
    print("This is the alert message: " + alert_object.text)
    #Enter text into the Alert using send_keys()
    alert_object.send_keys('Eugene')
    print("Entered my name in the prompt box")
    # Use the alert.accept() method to accept the alert
    alert_object.accept()
    print("Alert pop-up accepted by clicking the 'OK' button")

    # End the driver session
    driver.quit()

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.

Code Execution:

We then run the test script by running the following command in the terminal.

python -m  pytest test_handling_alerts.py

Once the test is executed, the following output is displayed to show that the Selenium automated test was successful.

You can view the test logs in the build section from the LambdaTest Automation Dashboard.

Code Walkthrough:

Let us review the code for the test script we wrote in the section above.

Step 1: Import the Selenium libraries needed to run the test.

In this case, we import pytest, a testing framework for Python that enables us to write unit tests. The By query helps us locate web elements within the Document Object Model (DOM) using the find_element() method in Selenium.

The WebDriverWait class combined with expected_conditions allows us to specify the period of time the script should wait for a given condition to occur before continuing with the code. Finally, the Options (ChromeOptions) class customizes the ChromeDriver sessions and helps us perform operations like opening the Chrome browser.

Step 2: Generate the options using the LambdaTest Capabilities Generator to run the test in the Chrome browser.

Step 3: Create a remote_url variable that connects to the Remote Selenium Grid (@hub.lambdatest.com/wd/hub) using the username and accesskey listed on the LambdaTest Profile page. We then pass the options and the remote_url to instantiate the driver constructor.

Step 4: Open the LambdaTest Playground website and locate the button that prompts the alert using its XPath Selector in the browser inspect tools, then click it to initiate the alert.

When the Click Me button is clicked, the below window will be shown with the prompt alert.

The WebDriver’s focus is then switched to the alert prompt using the switch_to.alert method. Since the alert requires an input, we use the send_keys() method in Selenium to pass a value (in this case, your name), and then we accept the alert pop-up using the accept() method. The WebDriver session is then closed using the driver.quit() method.

Drag and Drop Operations

The drag and drop operation in Selenium Python allows users to use a mouse to move (drag) web elements from one location to another. In test automation using Selenium Python, the drag and drop function can be difficult to automate since it necessitates several actions and interactions.

The ActionChains class in Selenium Python provides methods to simulate the mouse events required for drag-and-drop. The methods are typically used to automate actions like mouse movements, keystrokes, context menu clicks, and mouse button events. The ActionChains object implements the class as a queue and calls the perform() method, which executes the actions together to prevent the test failure.

The syntax for creating an ActionChains object is:

from selenium.webdriver import ActionChains
action = ActionChains(driver)

The drag_and_drop(source, target) method performs the action of holding the left mouse button on the source element and releasing the mouse button at the target element.

action.drag_and_drop(source, target).perform()

Demonstration: How to perform a Drag-and-Drop Operation in Selenium Python

Let us look at how we can handle a drag-and-drop operation in Selenium using Python.

Test Case:

To implement drag and drop, we will use the example of Drag Drop Range Sliders from the LambdaTest Selenium Playground.

Navigate to the Drag Drop Range Sliders demo page.
Locate the drag pointer and drag it from 5 (source) to 50 (target)

Implementation (Test Case on the Chrome Browser):

import os
import pytest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver import ActionChains


def test_handling_drag_and_drop():
    options = ChromeOptions()
    options.browser_version = "106.0"
    options.platform_name = "Windows 10"
    lt_options = {};
    lt_options["username"] = os.environ.get("LT_USERNAME");
    lt_options["accessKey"] = os.environ.get("LT_ACCESS_KEY");
    lt_options["visual"] = True;
    lt_options["build"] = "Handling Drag & Drop";
    lt_options["project"] = "Handling Drag & Drop";
    lt_options["name"] = "Handling Drag & Drop";
    lt_options["w3c"] = True;
    lt_options["plugin"] = "python-python";
    options.set_capability('LT:Options', lt_options);
    # LambdaTest Profile username
    user_name = os.environ.get('LT_USERNAME')
    # LambdaTest Profile access_key
    accesskey = os.environ.get('LT_ACCESS_KEY')
    remote_url =  "https://" + user_name + ":" + accesskey + "@hub.lambdatest.com/wd/hub"
    driver = webdriver.Remote(remote_url, options=options)
    driver.get("https://www.lambdatest.com/selenium-playground/drag-drop-range-sliders-demo")

    source = WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CSS_SELECTOR, "input[value='5']")))
    print("I am dragging the mouse from: ", source.get_attribute("value"))
    target = WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CSS_SELECTOR, "input[value='50']")))
    print("I'm dropping the mouse at: ", target.get_attribute("value"))
    driver.implicitly_wait(10)
    action = ActionChains(driver)
    action.drag_and_drop(source, target).perform()
    print("The mouse dragged from 5 to 50")
    driver.close()

Code Execution:

Pass the following command in the command line to execute the test script.

python -m pytest test_handling_drag_and_drop.py

The test passes once it runs and displays the following output in the terminal.

In the LambdaTest Automation Dashboard, you can see the results of the test execution. You can also see the live recordings of the test with detailed reports and logs.

Do you need to gather more knowledge on testing web? LambdaTest is here to explain further.

Code Walkthrough:

Step 1: Import the Selenium libraries essential to the test script, including the ActionChains class that replicates mouse events for our test automation.

Step 2: Using the driver.get(url) method, we navigate to the URL where our automated test will simulate the drag and drop operation.

Step 3: Next, locate the source web element and the target elements the mouse will drag and drop onto. We use the elements’ CSS Selectors to locate them from the web browser’s inspect tools. The source element has an input value of 5, which will be moved to the target element, which has an input value of 50.

Locating the source element using the CSS Selector in the Browser Inspect Tools:

Locating the target element using the CSS Selector in Browser Inspect Tools:

Step 4: You then create an object of ActionChains and invoke drag_and_drop(source, target).perform() method to execute the mouse movement from 5 to 50 in the draggable slide.

Step 5: We finally close the webdriver session using the driver.close() method.

Selecting Multiple Values in Drop-Down Menus

A drop-down is a navigation element of a website that can be used in forms, search filter features and the Navbar. It allows the selection of one or more options from a list of options.

Choosing multiple values from a drop-down menu while running automated tests in Selenium Python can be a challenge for testers. Automating the selection of multiple choices is complex, as the test script needs to identify the drop-down element with its options and then search through the list of options before selecting them.

In some instances, the drop-down menu options are dynamically generated and rendered differently based on the web browser or operating system used. This can make writing robust and efficient scripts challenging.

Below are screenshots of the same drop-down menu in Chrome and Firefox browsers on a Windows OS.

Drop-down menu in a Chrome browser:

Drop-down menu in a Firefox browser:

The drop-down menu background color and font type are different in both browsers.

We use the Select class when testing with Selenium Python to address this issue. The Selenium WebDriver provides the Select class to handle single-select and multiple-select drop-downs with the < select > HTML tag. In Selenium Python, there are several methods for selecting dropdowns.

We will implement the following three methods to select multiple values in our test scenario:

select_by_index(index)

This method uses the get_attribute(“index”) of a < option > tag to determine its index and return the matching option.This method uses the get_attribute(“index”) of a < option > tag to determine its index and return the matching option.

 multi_select = Select(dropdown)
 multi_select.select_by_index(0)

select_by_visible_text(text)

This method selects the options that display text that matches the argument passed. For example, the argument “Iowa” will select an option tag with < option > Iowa < /option >.

multi_select = Select(dropdown)
 multi_select.select_by_visible_text(“Iowa”)

select_by_value(value)

This method selects the options whose value corresponds to the value argument.

For example:

< option value=”AZ”> Arizona < /option >

multi_select = Select(dropdown)
 multi_select.select_by_value(“AZ”)

Demonstration: How to handle Multiple Values in a Drop-Down Menu using Selenium Python

Let us look at how to automate the selection of multiple values in the following test case scenario.

Test Case:

Navigate to the jQuery Dropdown Search demo page.
Go to the Multi Select section on the web page to choose multiple states.
Select 3 states from the dropdown menu.
Print the states selected.

Implementation (Test Case on the Chrome Browser):

import os
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.support.select import Select


def test_multiple_values_dropdown():
    options = ChromeOptions()
    options.browser_version = "107.0"
    options.platform_name = "Windows 10"
    lt_options = {};
    lt_options["username"] = os.environ.get("LT_USERNAME");
    lt_options["accessKey"] = os.environ.get("LT_ACCESS_KEY");
    lt_options["build"] = "Handling Multiple Values Selection in Dropdowns";
    lt_options["project"] = "Handling Multiple Values Selection in Dropdowns";
    lt_options["name"] = "Handling Multiple Values Selection in Dropdowns";
    lt_options["selenium_version"] = "4.0.0";
    lt_options["w3c"] = True;
    options.set_capability('LT:Options', lt_options);

    # LambdaTest Profile username
    user_name = os.environ.get('LT_USERNAME')
    # LambdaTest Profile access_key
    accesskey = os.environ.get('LT_ACCESS_KEY')
    remote_url =  "https://" + user_name + ":" + accesskey + "@hub.lambdatest.com/wd/hub"
    driver = webdriver.Remote(remote_url, options=options)
    driver.get("https://www.lambdatest.com/selenium-playground/jquery-dropdown-search-demo")

    # Find the multiselect dropdown element in the page
    dropdown = WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.XPATH, '//*[@id="__next"]/div/section[3]/div/div/div[2]/div[2]/div[2]/select')))

    # Using the webdriver Select class to select multiple values
    multi_select = Select(dropdown)
    driver.implicitly_wait(3)
    multi_select.select_by_index(0)
    driver.implicitly_wait(3)
    multi_select.select_by_value("AZ")
    driver.implicitly_wait(3)
    multi_select.select_by_visible_text("Iowa")
    print("All selected values using the SELECT Class in the dropdown are: \n")
    for option in multi_select.all_selected_options:
        print(option.get_attribute('innerText'))

    driver.close()

Code Execution:

Type the command below in the terminal to run the test script.

 python -m pytest test_multiple_values_dropdowns.py

The test executes successfully and displays the three selected states as the output.

You can view the status of your successful test run on your LambdaTest Automation Dashboard.

Inspect web elements to help developers and testers to debug UI flaws or make modifications in HTML or CSS files. Learn how to inspect element on Mac-Book.

Code Walkthrough:

Step 1: In the test script above, we import the necessary Selenium libraries required to run the script, including the Select class that will automate the selection of multiple options from a drop-down.

Step 2: Navigate to the website where we will run the test script using the driver.get() method. Using the Explicit wait with WebDriverWait, we wait for the drop-down element to appear and then locate it using XPath.

Step 3: We create an instance of the Select class using the Select() method by passing the multi_select element as its argument. We select multiple values from the drop-down menu using the select_by_index(), select_by_value(), and select_by_visible_text() methods.

Step 4: Then, use all_select_options() to iterate through the selected options and print the individual options we chose. The option tag’s text string will be printed by the get_attribute(“innerText”) function.

Step 5: Finally, calling the driver.close() ends the driver session.

jQuery Date Pickers

When automating an airline or hotel website or filling up a form on a website, you might come across a date picker or calendar to pick dates or even time. The jQuery calendar is the most commonly used date picker control. These calendars significantly enhance the user experience by making choosing dates easier and more dynamic.

jQuery date pickers can pose a challenge when automating web applications using Selenium Python.

The date pickers could implement multiple date and time formats, making it challenging as the test implementation will need to be adjusted to match the calendar’s style and appearance. The calendar may also require navigation controls such as previous and next buttons to choose different months and years to select the dates. The calendar date pickers may also be rendered differently depending on the browser.

Booking.com datepicker in the Chrome browser:

Booking.com datepicker in Firefox browser:

Demonstration: How to handle a jQuery Calendar in Selenium Python

Let’s look at a scenario on how to automate a jQuery calendar in Selenium Python.

Test Case:

Navigate to the jQuery Date Picker demo page.
Go to the Date Range Picker.
In the From date picker field, select 05/10/2023 as the date.
In the To date picker field, select 06/25/2023 as the date.
Print the dates selected.

Implementation (Test Case on the Chrome Browser):

import os
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.support.select import Select
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC


def test_handling_jquey_datepicker():
    options = ChromeOptions()
    options.browser_version = "107.0"
    options.platform_name = "Windows 10"
    lt_options = {};
    lt_options["username"] = os.environ.get('LT_USERNAME');
    lt_options["accessKey"] = os.environ.get('LT_ACCESS_KEY');
    lt_options["build"] = "Handling Date Pickers";
    lt_options["project"] = "Handling Date Pickers";
    lt_options["name"] = "Handling Date Pickers";
    lt_options["w3c"] = True;
    lt_options["plugin"] = "python-python";
    options.set_capability('LT:Options', lt_options)
    # LambdaTest Profile username
    user_name = os.environ.get('LT_USERNAME')
    # LambdaTest Profile access_key
    accesskey = os.environ.get('LT_ACCESS_KEY')
    remote_url =  "https://" + user_name + ":" + accesskey + "@hub.lambdatest.com/wd/hub"
    driver = webdriver.Remote(remote_url, options=options)
    # Handling JQuery DatePicker
    driver.get('https://www.lambdatest.com/selenium-playground/jquery-date-picker-demo')

    # expected dates to be selected
    from_date_target = '05/10/2023'
    to_date_target = '06/25/2023'

    from_date = '10'
    to_date  = '25'


    # From date
    # clicking on the from_date picker
    from_date_picker = driver.find_element(By.XPATH, "//input[@id='from']")
    from_date_picker.click()

    from_month = driver.find_element(By.XPATH, "//select[@class='ui-datepicker-month']")
    # We use the Select() method to select the target month we want
    from_month_selected = Select(from_month)
    from_month_selected.select_by_visible_text('May')

    from_day = WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.XPATH,"//td[not(contains(@class,'ui-datepicker-month'))]/a[text()='" + from_date + "']")))
    from_day.click()


    # To date
    to_date_picker = driver.find_element(By.XPATH, "//input[@id='to']")
    to_date_picker.click()

    to_month = driver.find_element(By.XPATH, "//select[@class='ui-datepicker-month']")
    to_month_selected = Select(to_month)
    to_month_selected.select_by_visible_text('Jun')    

    to_day = WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.XPATH,"//td[not(contains(@class,'ui-datepicker-month'))]/a[text()='" + to_date + "']")))
    to_day.click()


    # Assert the selected dates
    expected_from_date = from_date_picker.get_attribute('value')
    if expected_from_date == from_date_target:
        print("From date selected:", expected_from_date)

    expected_to_date = to_date_picker.get_attribute('value')
    if expected_to_date == to_date_target:
        print("To date selected:", expected_to_date)

    driver.close()

Code Execution:

To run the test script above in the terminal, run the following command:

python -m pytest test_handling_datepickers.py

The test script executes successfully and will display the following output.

You can also view test results on the LambdaTest Dashboard.

Video recording of From date selection:

Video recording of To date selection:

Code Walkthrough:

Step 1: Import the Select class from Selenium WebDriver to help us implement the < select > tag, which provides the helper methods with select and deselect options.

Step 2: Define the from_date target and to_date_target date targets that we want to select from the datepicker.

Step 3: The from_date_picker element is located using XPath in the Chrome Developer Tools and clicked to open the calendar.

Step 4: From the calendar, we locate from_month using XPath and select the month using the Select() method. In this instance, we select the month of May using the select_by_visible_text() method.

Step 5: Since we have specified the precise value of the from_date, the 10th day is located from the month using a dynamic XPath, and the contains() method. We then click on the day.

Given that the datepicker provides date range capability, the procedures implemented for the from_date are also applied to the to_date. The only difference comes from the months and locators used to locate the “from” and “to” dates. We selected June and the sixth day for the to_ date.

Step 6: Finally, we ascertain that the from_date_picker and the to_date_picker variables have the exact value we specified in the from_date_target and the to_date_target variables using the get_attribute(‘value’) method.

We store these values in the expected_from_date and expected_to_date variables and print the output.

Step 7: We then close the WebDriver session with the driver.close() method.

Mouse Hover Elements

A mouse hover action is an action taken when a user moves a mouse cursor over a designated part of a webpage, and it triggers a specific event. For example, in the Selenium eCommerce Playground website, hovering over a product element will show a sub-menu of a user’s actions, such as the “Add to Cart” function.

Mouse hover can also be used on banks’ websites to show different services the bank offers, as well as on hotel websites to zoom in on a location’s picture or add the location to likes.

Mouse hover on product item showing “Add to Cart” action:

Mouse hover on the bank website showing the bank’s services:

Hover elements can pose a challenge while writing automated tests using Selenium Python. Some elements are often hidden and only become visible when the mouse hovers over some other element, making it difficult to locate them using the standard find_element() method.

Additionally, hover events can be unstable as they depend on the mouse movement speed and the timing of triggering the hover event. In the case of slow internet speeds, the mouse cursor movements might lag. This may result in the tests being flaky.

To handle mouse hover actions, we implement the methods from the ActionChains class. The class methods will simulate the mouse movement.

Demonstration: How to handle Mouse Hover Actions in Selenium Python

Let us look at a test case scenario that requires handling a mouse hover action.

Test Case:

Navigate to the LambdaTest Selenium eCommerce Playground.
Go to product items and hover the mouse on the item.
Click on the Add to Cart button that hovers over the product item.
Print that the item has been added to the cart successfully.

Implementation (Test Case on the Chrome Browser):

import os
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver import ActionChains
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import time

def test_mouse_hover():
    options = ChromeOptions()
    options.browser_version = "107.0"
    options.platform_name = "Windows 10"
    lt_options = {};
    lt_options["username"] = os.environ.get("LT_USERNAME");
    lt_options["accessKey"] = os.environ.get("LT_ACCESS_KEY");
    lt_options["build"] = "MouseHoverHandling";
    lt_options["project"] = "MouseHoverHandling";
    lt_options["name"] = "MouseHoverHandling";
    lt_options["selenium_version"] = "4.0.0";
    lt_options["w3c"] = True;
    options.set_capability('LT:Options', lt_options);

    # LambdaTest Profile username
    user_name = os.environ.get('LT_USERNAME')
    # LambdaTest Profile access_key
    accesskey = os.environ.get('LT_ACCESS_KEY')
    remote_url =  "https://" + user_name + ":" + accesskey + "@hub.lambdatest.com/wd/hub"
    driver = webdriver.Remote(remote_url, options=options)

    driver.get("https://ecommerce-playground.lambdatest.io/")
    driver.implicitly_wait(10)
    # Find the element we want to hover
    product_item = driver.find_element(By.XPATH, '//*[@id="mz-product-listing-image-37213259-0-0"]/div/div[1]/img')

    # Create a sequence of actions through the ActionsChains class
    driver.implicitly_wait(10)
    actions = ActionChains(driver)
    # Perform triggers the actions
    actions.move_to_element(product_item).perform()
    driver.implicitly_wait(10)

    # find the add_to_cart element we want to click on the product elementa
    add_to_cart = driver.find_element(By.CSS_SELECTOR, 'button[title="Add to Cart"]')
    # The mouse will click the add_to_cart element to complete the sequence.
    driver.implicitly_wait(10)
    actions.click(add_to_cart)
    print("Item moved to the cart")

    driver.close()

Code Execution:

Type the following command in the terminal to run the test script.

python -m pytest test_mouse_hover.py

The test successfully executes on the terminal, displaying the output as shown below.

The test results can be viewed in the LambdaTest Dashboard.

Code Walkthrough:

Step 1: Import the ActionChains class from the Selenium WebDriver, which provides a variety of APIs for keyboard and mouse actions.

Step 2: Navigate to the Selenium eCommerce Playground website using the driver.get() method. We first locate a product element in the webpage using its XPath from the Chrome Browser’s Inspect Tools to display the hover effect.

Step 3: Using the ActionChains class, we create an object of the class and use the move_to_element() method with the product_item element as its parameter. The move_to_element() method moves the mouse to the middle of the element. Then apply the perform() method to implement the mouse action.

Once the mouse cursor is on the product_item element, we locate the add_to_cart button using its CSS Selector. The add_to_cart element becomes visible when the mouse hovers over the product_item and then clicks on it using the actions class object.

Step 4: We finally close the webdriver session using the driver.close() method.

Perform manual or automated cross browser test on 3000+ browsers online. Deploy and scale faster with the most powerful cross browser testing tool online.

AJAX Form Submission

AJAX forms are a challenge in automation testing using Selenium Python because of the asynchronous nature of AJAX calls. AJAX calls can be used in web apps to enable features such as autocomplete search, which displays results as you type, or infinite scrolling to fetch additional content in social media apps without reloading the page.

When you fill in and submit the traditional forms, the page reloads, and the refreshed page can be interacted with easily using Selenium. AJAX forms, on the other hand, do not require a page reload because the form data is delivered and handled asynchronously in the background. As new content is received from the server, a part of the web page’s DOM is updated rather than the entire DOM state changing. This can make it difficult to determine whether the form has completed processing and if the refreshed page content is accessible to be interacted with through Selenium.

To automate handling AJAX form submissions, we use the explicit wait functions to wait for the refreshed page to load before proceeding with the code. On the other hand, implicit waits are not recommended for handling AJAX form submissions because they do not wait for a specific form submission to complete before continuing with the test script. The test script will continue to execute without waiting for the request to complete. This causes the test to be flaky because of wait time issues.

Demonstration: How to handle AJAX Form Submission using Selenium Python

To demonstrate handling AJAX form submissions, we will use the AJAX contact form by Getform.io.

Test Case:

Navigate to the Getform CodePen URL.
Fill in the form details and click on the Submit button.
Wait for the submission response and print it.

Implementation (Test Case on the Chrome Browser):

import os
import pytest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.support.select import Select


def test_AJAX_forms():
    options = ChromeOptions()
    options.browser_version = "107.0"
    options.platform_name = "Windows 10"
    lt_options = {};
    lt_options["username"] = os.environ.get("LT_USERNAME");
    lt_options["accessKey"] = os.environ.get("LT_ACCESS_KEY");
    lt_options["build"] = "Handling AJAX Forms";
    lt_options["project"] = "Handling AJAX Forms";
    lt_options["name"] = "Handling AJAX Forms";
    lt_options["w3c"] = True;
    lt_options["plugin"] = "python-python";
    options.set_capability('LT:Options', lt_options);

    # LambdaTest Profile username
    user_name = os.environ.get('LT_USERNAME')
    # LambdaTest Profile access_key
    accesskey = os.environ.get('LT_ACCESS_KEY')
    remote_url =  "https://" + user_name + ":" + accesskey + "@hub.lambdatest.com/wd/hub"
    driver = webdriver.Remote(remote_url, options=options)

    driver.get("https://codepen.io/getform/pen/jRoexL")

    # Get into the iFrame
    driver.switch_to.frame(driver.find_element(By.TAG_NAME, "iframe"))

    # Locate the Form
    form = driver.find_element(By.XPATH, '//*[@id="AJAXForm"]')
    # Identify the forms inputs and enter data through send_keys  
    email_element = form.find_element(By.XPATH, '//*[@id="exampleInputEmail1"]')
    email_element.send_keys('youremail@gmail.com')
    name_element = form.find_element(By.XPATH, '//*[@id="exampleInputName"]')
    name_element.send_keys('yourname')
    # Locate the dropdown
    platform_element = Select(form.find_element(By.XPATH, '//*[@id="exampleFormControlSelect1"]'))
    platform_element.select_by_visible_text('Github')
    submit = form.find_element(By.XPATH, '//*[@id="AJAXForm"]/button')
    submit.click()

    # Wait for the AJAX request to complete
    response = WebDriverWait(driver, 10).until(EC.visibility_of_element_located((By.XPATH, '//*[@id="AJAXForm"]/div[4]')))
    print(response.text)

    driver.quit()

Code Execution:

Let us run the test script in the terminal using the following command:

python -m pytest test_handling_AJAX_forms.py

The test executes successfully, and the terminal displays the form’s response.

We can view the test results in the LambdaTest Automation Dashboard.

Code Walkthrough:

Step 1: To get started with the automated testing of an AJAX form submission test scenario in Selenium Python, we import the necessary Selenium libraries, including WebDriverWait, and the expected conditions for the explicit wait. The explicit wait will enable the WebDriver to wait until the form submission returns the response, and it becomes visible in the DOM.

Step 2: We also import the Select class to handle the drop-down input menu in the form.

Step 3: The AJAX form is inside an iFrame, and the test script cannot continue to run until we switch the WebDriver’s context to the iFrame. In the Inspect Tool, the iFrame is identified by its TAG_NAME. We then switch to the iFrame using the driver.switch_to.frame() method with the iFrame element as its parameter.

Step 4: After switching to the iFrame, we locate the form using XPath from the Inspect Tools. After locating the email and name inputs, we use the send_keys() method to fill in the email and name details.

Step 5: The Select class we imported will select an option from the platform_element drop-down menu using the select_by_visible_text() method. Finally, click on the Submit button to submit the form details.

Step 6: After submitting the form, we use explicit wait to wait for the web page to load asynchronously until the response element is present in the DOM. Then print the response’s text.

Step 7: The driver.quit() closes the driver session.

Dynamic Page Elements

If an element in a web application has attributes such as Class, ID, or XPath that change when the web application is reloaded, such elements are known as dynamic web elements. For example, the login web element ID on the Facebook login page changes every time the page is reloaded.

In the below image, the login button ID is “u 0 5 aj.”

After the page is reloaded, the login button ID is now “u 0 5 Hg.”

Dynamic content can be challenging to automate with Selenium Python because it requires the automated test to identify and interact with the dynamic web elements. When a dynamic page element on a web page loads, not all elements are available immediately. When the WebDriver tries to interact with an element before it is present, it results in a NoSuchElementException.

Stale elements, on the other hand, are elements that are no longer attached to the web page’s DOM because the page has been reloaded or the element has been removed and replaced by another element. If the WebDriver tries to interact with a stale element, it results in a StaleElementReferenceException.

You can learn more about it through this blog on handling Errors and Exceptions in Selenium Python.

To address this challenge, automated test scripts need to implement explicit waits to wait until the page has finished loading before interacting with elements, as well as dynamic locators to locate and interact with elements that may not exist when the test is initially executed.

Demonstration: How to handle Dynamic Content with Selenium Python

Let us look at a test scenario to handle dynamic content on a website.

Test Case:

Navigate to the Internet HerokuApp link.
Click on the Start button and wait for the web page to load.
Print the response displayed.

Implementation (Test Case on the Chrome Browser):

import os
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options as ChromeOptions


def test_dynamic_content():
    options = ChromeOptions()
    options.browser_version = "107.0"
    options.platform_name = "Windows 10"
    lt_options = {};
    lt_options["username"] = os.environ.get("LT_USERNAME");
    lt_options["accessKey"] = os.environ.get("LT_ACCESS_KEY");
    lt_options["build"] = "Handling Dynamic Content";
    lt_options["project"] = "Handling Dynamic Content";
    lt_options["name"] = "Handling Dynamic Content";
    lt_options["w3c"] = True;
    lt_options["plugin"] = "python-python";
    options.set_capability('LT:Options', lt_options);

    # LambdaTest Profile username
    user_name = os.environ.get('LT_USERNAME')
    # LambdaTest Profile access_key
    accesskey = os.environ.get('LT_ACCESS_KEY')
    remote_url =  "https://" + user_name + ":" + accesskey + "@hub.lambdatest.com/wd/hub"
    driver = webdriver.Remote(remote_url, options=options)

    driver.get("https://the-internet.herokuapp.com/dynamic_loading/2")
    # locate the button start to dynamically
    start_button = driver.find_element(By.XPATH, '//*[@id="start"]/button')
    start_button.click()
    # Waiting for the text to appear after clicking the start_button
    finish_element = WebDriverWait(driver, 30).until(EC.visibility_of_element_located((By.XPATH, '//*[@id="finish"]/h4')))
    print(finish_element.text)


    driver.quit()

Code Execution:

Run the command below in the terminal to execute the test script.

python -m pytest test_handling_dynamic_content.py

Once the test runs, the following output will be displayed in the terminal.

We can see the status of the test execution and logs in the LambdaTest Automation Dashboard.

Code Walkthrough:

Step 1: Import the necessary Selenium libraries to run the test script, including the WebDriverWait class and expected_conditions that provide the explicit wait.

The WebDriver navigates to the website using the driver.get() method, locates the start_button element using its XPath in the Inspect Tools, and clicks on it.

Step 2: Using the WebDriverWait class, the WebDriver waits for the visibility of the response (finish_element) using an explicit wait. Once the element is present in the DOM, we print its text. The WebDriver will raise a TimeoutException, and the code will stop running if the finish_element is not visible in the DOM after the explicit wait period. The exception can be caught using a try-except block.

Step 3: Finally, the driver.close() method ends the WebDriver session.

Uploading Files

Uploading a file involves searching for a file at the required location or on your computer and uploading it to the website. This action can be done on specific websites, such as forms, document uploaders, and registration pages.

Uploading files can be challenging when performing automation tests with Selenium Python. The file dialog box that appears when you click the upload button is a native OS-level component and can be difficult to interact with programmatically, making it difficult to simulate the file selection process.

Additionally, different web applications might support various file formats for upload, and the same file upload element might behave differently depending on the file type. This can make writing reliable tests that function across several programs and file types difficult.

To handle this challenge, we will use the send_keys() method to upload the file. This approach is applicable to file upload elements with the tagname input and the type attribute set to the file. The send_keys() method will take the absolute path of the file as its argument and upload it to the web application we are testing.

Demonstration: How to Upload a File with Selenium Python

Let us look at a scenario for uploading a file when conducting automation testing with Selenium Python.

Test Case:

Navigate to the jQuery File Upload Demo page.
Locate and click on the Add files button on the webpage.
Choose a file you want to upload and click on Open.
Click on the Start button to upload the file.
Print that the file has been uploaded successfully.

Implementation (Test Case on a Chrome Browser):

import os
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC


def test_file_uploads():
    options = ChromeOptions()
    options.browser_version = "107.0"
    options.platform_name = "Windows 10"
    lt_options = {};
    lt_options["username"] = os.environ.get("LT_USERNAME");
    lt_options["accessKey"] = os.environ.get("LT_ACCESS_KEY");
    lt_options["build"] = "Handling File Upload";
    lt_options["project"] = "Handling File Upload";
    lt_options["name"] = "Handling File Upload";
    lt_options["w3c"] = True;
    lt_options["plugin"] = "python-python";
    options.set_capability('LT:Options', lt_options);

    # LambdaTest Profile username
    user_name = os.environ.get('LT_USERNAME')
    # LambdaTest Profile access_key
    accesskey = os.environ.get('LT_ACCESS_KEY')
    remote_url =  "https://" + user_name + ":" + accesskey + "@hub.lambdatest.com/wd/hub"
    driver = webdriver.Remote(remote_url, options=options)
    # Access website to automate file upload
    driver.get("https://blueimp.github.io/jQuery-File-Upload/")
    # locate the file upload button on the page using XPATH
    file_upload = WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.XPATH, "//input[@name='files[]']")))
    # The Send Keys method will include the path for the file that will be uploaded.
    file_upload.send_keys(r"C:\Users\Pictures\Saved Pictures\logo.jpg")

    start_upload = WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.XPATH,'//*[@id="fileupload"]/table/tbody/tr/td[4]/button[2]')))
    start_upload.click()

    # is_displayed method is used to check if an element is visible to the user or not.
    if driver.find_element(By.XPATH, '//*[@id="fileupload"]/table').is_displayed:
        print("file uploaded successfully")
    else:
        print("File not uploaded")

    driver.close()

Code Execution:

Let us run the test script in the terminal with the following command:

python -m pytest test_upload_files.py

The test executes successfully and returns the following output in the terminal.

The test execution status can be viewed on the LambdaTest Automation Dashboard.

Code Walkthrough:

Step 1: After creating an instance of the WebDriver, we navigate to the URL link using the driver.get() method. The file_upload element is then located using XPath. To upload a file, the send_keys() method takes an absolute path from the operating system’s directory, where the file is stored as its argument. The file_upload element has a tagname of input and a type attribute of the file; hence, we could use the send_keys() method to upload the file.

Step 2: We locate the start_upload button element by using an explicit wait to wait for the element to appear on the DOM after the file is selected from the file upload window. Once the button appears, we click on it to upload the file to the website.

Step 3: To check if the file uploaded is in the web application’s DOM, we use the is_displayed() method. If the uploaded file is present, we print that the file has been uploaded successfully. If not, the test prints that the file has not been uploaded. Finally, the WebDriver is closed using the driver.close() method.

If you want to automate user actions on a website to verify its functionality, commands for WebElements in Selenium Python play an important role. These commands can help you automate website testing in a more detailed manner. It’s recommended to run Selenium tests on real browsers, and operating systems will help you get accurate results.

Digital experience testing platforms like LambdaTest enables developers and QA to perform automated Selenium testing using Python on an online browser farm of 3000+ real browsers and OS combinations. LambdaTest offers support for different Python testing frameworks, including pytest, Robot, Behave, and more. In addition, you can perform parallel test execution to expedite your software release cycle.

Test your native, hybrid, and web apps across all legacy and latest mobile operating systems on the most powerful online Android emulator.

Conclusion

In this blog on WebElements in Selenium Python, we have demonstrated different ways to handle WebElements in Selenium Python. These include handling alert pop-ups, drag-and-drop operations, jQuery datepickers, hover elements, AJAX forms, etc. We have also looked at the approaches to handle them, such as the use of explicit waits, the ActionChains class, Select, and send_keys methods.

How To Handle Errors And Exceptions In Selenium Python

EugeneKwaka — Thu, 01 Dec 2022 14:34:00 +0000

In the world of automation testing, Selenium is a free and open-source framework used to perform web application testing in web browsers like Chrome, Safari, Firefox, Opera, and Edge. You can write Selenium IDE tests using various programming languages such as Python, Java, JavaScript(Node.js), Kotlin, Ruby, PHP, and C#.

While the advantages of automated testing using Selenium are endless, there are incidences of errors and exceptions that happen regularly in the testing tool (or framework). When a program’s execution is disrupted during run-time, an exception is raised, preventing further instructions from being executed. Runtime errors are raised when you perform an unanticipated operation during runtime.

Exception and error handling is a programming mechanism by which the occurrence of errors and exceptions that halt the execution of a program are responded to by the program to ensure the normal execution of code.

In this blog on handling exceptions in Selenium Python, we will look at the variety of exceptions and errors that can happen when a Selenium test is running. By the end of this blog, you will be able to implement error and exception handling for Selenium automation tests.

So, let’s get started!

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

Introduction to Errors and Exceptions in Selenium Python

For a program or application to run, a developer must write code that tests every aspect of its functionality. However, the instructions outlined in the code sometimes do not execute as intended.

For QA engineers, the same rule holds when writing code used to test the features and functionality of the applications that have been created to ensure that the application is ready for production and then shipped to the users.

Here is an analogy to help you better understand errors and exceptions in Selenium Python.

Imagine you have a work meeting on Zoom or any online video conference application while at home. During the meeting, the electricity was cut off, which is reported to have affected the whole city. You have no choice but to call off the meeting and wait for the electricity to be reinstated. Akin to this, errors are raised during runtime, and rectifying them is nearly impossible.

In contrast, exceptions are events that raise interruptions while an application runs and can be rectified using exception handling.

Exceptions in Selenium Python are generally classified into two types.

Checked Exceptions
Unchecked Exceptions

Checked Exception handling in Selenium is conducted while writing the code. On the other hand, Unchecked Exceptions are raised during runtime and can generate fatal errors compared to the former type of exception.

You can quickly sharpen your knowledge of exceptions in Selenium Python by reading through this detailed blog on different exceptions in Selenium.

Performing Selenium automated browser testing differs across the ecosystem in which the tests are being carried out. The test scripts may differ depending on the operating systems, browsers, or programming languages they are written in. Therefore, the raised errors andexceptions in Selenium Python may be different. For example, if the browsers don’t have the specified element, Selenium testing of an element property in web browsers may raise exceptions like NoSuchElementException.

To ensure that the applications function correctly and obstruct users’ interactions with the finished product, it is advised that Selenium error and exception handling be used as a standard practice.

Test on Selenium Automation Grid Cloud of 3000+ Desktop & Mobile Browsers.

Common Exceptions in Selenium Python

According to a recent Stack Overflow developer survey, Python is the fourth most popular programming language among developers.

It offers a robust support system for test automation frameworks and is the most user-friendly and straightforward programming language available.

Errors and exceptions in Selenium Python are common and can occur when writing tests. The exception instances must be derived from a class that inherits from BaseException. If two exception instances do not have a subclass relationship, they are not considered equal despite having the same properties, such as names.

While writing code for the test scripts, the code can run into built-in exceptions, or you can raise exceptions in the code. The interpreter or built-in functions generate the built-in exceptions.

The selenium.common.exceptions package contains the exception classes, which can be imported in the following way.

Syntax: from selenium.common.exceptions import [Exception Name]

An example of an exception being imported is below:

This exception indicates that the website does not contain the attribute of the element being looked for.

Other exceptions in Selenium Python include:

TimeOutException

When a command does not complete in the time duration set (seconds), this exception is raised or thrown. The wait time can either be implicitly or explicitly defined.

NoSuchElementException

When an element cannot be found, this exception is raised or thrown. Nonetheless, different factors can lead to this exception being generated:

The element is not yet in the DOM when the find operation is performed because the page loading is in progress.
Incorrect element locator is used in the source code.
ElementNotInteractableException

Such exceptions in Selenium Python is raised whenever an element in the DOM is present but cannot be interacted with.

ElementNotVisibleException

This exception typically arises when the interaction involves clicking or reading text from an element that is not visible in the DOM.

StaleElementReferenceException

An outdated or unavailable element in the DOM is referred to as a stale element. A reference to an element that is currently “stale” will raise or throw this exception.

For example, the following reasons could lead to the StaleElementReferenceException exception:

After the element was located, the page either changed or was refreshed.
A refreshed context may have contained the element.
Complete deletion of the referenced web element.
ElementClickInterceptedException

This exception arises when the element receiving the interaction impedes the element intended to be clicked, thereby preventing the Element Click operation from being performed.

NoSuchCookieException

This exception will be raised if a cookie with the specified path name is not contained amongst the corresponding cookies of an active document in the current browsing session. To learn more about cookies in Selenium, check out this detailed tutorial on handling cookies in the Selenium WebDriver.

Watch this video to understand how you can handle Cookies and perform different operations like deleting, getting the parameter values, and adding them to Selenium WebDriver using Java.

InvalidArgumentException

A command with improper or incorrect argument inputs will raise an InvalidArgumentException.

InvalidElementStateException

This exception is raised when we try to perform an operation that does not apply to an element. For example, if we perform a click operation on a radio button that is disabled, the exception will be raised, and hence the command given cannot be executed.

NoSuchWindowException

This exception is thrown when the intended window target cannot be found.

If you are a Python programmer looking to make a mark, you can take your career to the next level with the Selenium Python 101 certification from LambdaTest.

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

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

Handling Errors and Exceptions in Selenium Python

Handling errors and exceptions in Selenium Python are vital when writing production-ready code, since exceptions and errors can arise for different reasons, as discussed earlier.

A prerequisite to writing tests using Selenium Python is to install Python and Selenium on your machine. When using Python for Selenium testing, the default framework used is PyUnit, also known as unittest, which is influenced by JUnit. It functions similarly to other unit testing frameworks.

However, in this blog on handling errors and exceptions in Selenium Python, we will use Pytest, another Python testing framework that supports functions, APIs, and unit testing. It is compatible with the current versions of Python and is easy to configure using the Python Package Manager (pip) command in the terminal.

If you are new to testing using Selenium Python, here is a detailed step-by-step tutorial on how to get started with Selenium Python. You will learn how to configure Python, Selenium, and Pytest on your machine to start automation testing with Selenium. You can learn more about Pytest through this Selenium Pytest tutorial.

Project Setup

For the test project setup, we are using the Visual Studio (VS) Code IDE to write the test scripts. Alternatively, there are other IDEs available, such as Pycharm, Atom, and Sublime Text, that you can use as well.

For the package manager, we will use Poetry, a Python tool that manages and packages the necessary dependencies in a specific virtual environment for your project. You can declare the libraries your project depends on, and it will take care of managing (installing and updating) them.

1- To install Poetry on your local machine’s terminal, please use the following command:

For Windows

pip install poetry

For Mac

pip3 install poetry(depends on the Python version you are using).

2- Move to the directory where your project will be contained.

3- To initialize Poetry in the terminal, we use the command poetry init. This command will generate a pyproject.toml configuration file containing the build system requirements for Python projects.

4- We need the following libraries in our project to run Selenium Python tests:

selenium (v 4.3.0)
flake8 (v 4.0.1)
pytest (v 7.1.2)
pytest-xdist (v 2.5.0)
autopep8 (v 1.6.0)

The pytest-xdist plugin adds new test execution modes to Pytest, allowing us to run parallel Selenium Python tests. Autopep8 formats the Python code to adhere to the PEP 8 style manual. Flake8 is a great tool that tests your code for errors against the PEP 8 style guide.

5- Adding Selenium:

6- Adding pytest:

7- Adding pytest-xdist.

8- Adding autopep8.

9- Adding flake8.

10- After installing the required dependencies, continue to press Enter, then confirm the generation of the file.

11- The pyproject.toml file contains all the packages that must be installed in the virtual environment.

[tool.poetry]
name = "tests"
version = "0.1.0"
description = ""
authors = ["Eugene Kwaka <eugenekwaka@gmail.com>"]

[tool.poetry.dependencies]
python = "^3.7"
selenium = "^4.3.0"
pytest = "^7.1.2"
pytest-xdist = "^2.5.0"
autopep8 = "^1.6.0"
flake8 = "^4.0.1"

[tool.poetry.dev-dependencies]

[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"

To install the dependencies mentioned, run the following command to create the pyproject.toml and poetry.lock files in the directory.

A virtual environment (venv) containing the dependencies installed will be automatically created by Poetry. This is important since we do not want to mix Python’s global dependencies with the specific dependencies we require to run the tests in the project.

In our project, we create a folder that will hold the test functions. Let’s call it “seltests”.

Perform manual or automated cross browser testing on 3000+ browsers online. Deploy and scale faster with the most powerful cross browser test tool online.

Handling Errors and Exceptions on the Cloud Selenium Grid

Now that we have covered the essentials to get started with Python web automation in Selenium, we will look at handling errors and exceptions in Selenium Python on a cloud grid. In this instance, we are using LambdaTest.

LambdaTest is a cloud-based cross browser testing platform that allows you to perform Python automation testing at scale over a cloud Selenium Grid. The unique and fully featured platform offers an online browser farm of 3000+ real browsers across multiple operating systems; thus helping businesses deliver more quality software at a more rapid speed.

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around automated browser testing, Selenium testing, Cypress E2E testing, CI/CD, and more.

To get started with LambdaTest, please follow the below-mentioned steps:

Register and log in to your LambdaTest account.
Move to the LambdaTest Profile Section and copy your username and access key, which will be used to access the Remote Selenium Grid of LambdaTest.
You will also need the desired capabilities generated using the LambdaTest Capabilities Generator. You can generate the capabilities needed for the specific test you are carrying out on that page.

We have listed the different types of exceptions in Selenium Python in the blog. Now, we will dig deeper into two common exceptions in Selenium Python when performing automated tests.

NoSuchElementException

A NoSuchElementException is thrown if we attempt to locate any element unavailable on the page (or the DOM).

Scenario 1 (Chrome Browser)

Go to the URL link https://www.lambdatest.com/selenium-playground/.
Locate an element called “p-10” by its name.
Click on the element.

Scenario 2 (Firefox Browser)

Go to the URL link https://www.lambdatest.com/selenium-playground/.
Locate an element called “level-up” by its name.
Click on the element.

Implementation (Scenario 1 on the Chrome Browser):

FileName — test_nosuchelement_google.py

import pytest
from selenium import webdriver
import sys
from selenium.webdriver.common.by import By
from selenium.common.exceptions import NoSuchElementException


# Desired Capabilities according to SELENIUM 4
ch_capabilities = {
  'LT:Options' : {
   "user" : "<username>",
   "accessKey" : "<accesskey>",
   "build" : "NoSuchElementException Test on Chrome",
   "name" : "NoSuchElementException Test on Chrome",
   "platformName" : "Windows 10"
  },
  "browserName" : "Chrome",
  "browserVersion" : "102.0",
 }


def test_lambdatest_nosuchelement():
    # LambdaTest Profile username
    user_name = "<username>"
    # LambdaTest Profile access_key
    app_key = "<accesskey>"
    # Remote Url to connect to our instance of LambdaTest
    remote_url = "https://" + user_name + ":" + app_key + "@hub.lambdatest.com/wd/hub"
    ch_driver = webdriver.Remote(
        command_executor=remote_url, desired_capabilities = ch_capabilities)
    ch_driver.get('https://www.lambdatest.com/selenium-playground/')
    ch_driver.maximize_window()
    # will find an element by its NAME property on the page and click it
    ch_driver.find_element(By.CLASS_NAME, "p-10").click()
    ch_driver.quit()

Implementation (Scenario 2 on the Firefox Browser):

FileName — test_nosuchelement_firefox.py

import pytest
from selenium import webdriver
import sys
from selenium.webdriver.common.by import By
from selenium.common.exceptions import NoSuchElementException

# Desired Capabilities according to SELENIUM 4
ff_capabilities = {
        'LT:Options' : {
            "user" : "<username>",
            "accessKey" : "<access_key>",
            "build" : "NoSuchElementException Test for LambdaTest (Firefox)",
            "name" : "NoSuchElementException Test for LambdaTest (Firefox)",
            "platformName" : "Windows 10"
        },
        "browserName" : "Firefox",
        "browserVersion" : "101.0",
    }

def test_lambdatest_firefox():
    # LambdaTest Profile username
    user_name = "<username>"
    # LambdaTest Profile access_key
    app_key = "<access_key>"
    # Remote Url to connect to our instance of LambdaTest
    remote_url = "https://" + user_name + ":" + app_key +   "@hub.lambdatest.com/wd/hub"
    # creating an instance of Firefox based on the remote url and the desired capabilities
    ff_driver = webdriver.Remote(
        command_executor=remote_url, desired_capabilities = ff_capabilities)
    ff_driver.get('https://www.lambdatest.com/selenium-playground/')
    # This will maximize the window interface of the driver class in this case it's FIREFOX
    ff_driver.maximize_window()
    # Will find an element by its NAME property in the page and click it
    ff_driver.find_element(By.CLASS_NAME, "level-up").click()
    ff_driver.quit()

Code Execution:

We run the two test scripts using parallel testing, which allows the execution of the same tests simultaneously. To run the test, type the following command in the terminal.

poetry run pytest seltests/test_nosuchelement_google.py seltests/test_nosuchelement_firefox.py -n 2

The terminal shows that the test execution failed.

In the LambdaTest Builds dashboard, the failed test executions are displayed.

Code Walkthrough:

We are conducting a joint code walkthrough because the imported Selenium Python libraries used in both test scenarios are identical.

Step 1: Import the necessary Selenium Python classes — pytest, webdriver, sys, By, NoSuchElementException.

import pytest
from selenium import webdriver
import sys
from selenium.webdriver.common.by import By
from selenium.common.exceptions import NoSuchElementException

We imported pytest, primarily used for unit testing in Selenium Python. Selenium WebDriver is a web framework that enables us to perform cross-browser testing, and in this case, we are using Python to write the test scripts. The By query is based on the find_element() method in Selenium that targets a specific locator.

Step 2: We specify the browser capabilities based on the browser we use to conduct the automated tests in LambdaTest. They are generated using the LambdaTest Capabilities Generator.

Chrome

ch_capabilities = {
        'LT:Options' : {
            "user" : "<username>",
            "accessKey" : "<accesskey>",
            "build" : "NoSuchElementException Test on Chrome",
            "name" : "NoSuchElementException Test on Chrome",
            "platformName" : "Windows 10"
        },
        "browserName" : "Chrome",
        "browserVersion" : "102.0",
    }

Firefox

ff_capabilities = {
        'LT:Options' : {
            "user" : "<username>",
            "accessKey" : "<accesskey>",
            "build" : "NoSuchElementException Test for LambdaTest (Firefox)",
            "name" : "NoSuchElementException Test for LambdaTest (Firefox)",
            "platformName" : "Windows 10"
        },
        "browserName" : "Firefox",
        "browserVersion" : "101.0",
    }

Step 3: We define a function that starts with “test” in which we assign the test methods. You can learn more about it through this blog on Pytest testing using Selenium WebDriver.

def test_lambdatest_nosuchelement():

Step 4: We then set our LambdaTest username and accesskey to variables we appended to remote_url. This remote URL connects us to the Remote Selenium Grid (@hub.lambdatest.com/wd/hub).

# LambdaTest Profile username
    user_name = "<username>"
    # LambdaTest Profile access_key
    app_key = "<accesskey>"
    # Remote Url to connect to our instance of LambdaTest
    remote_url = "https://" + user_name + ":" + app_key + "@hub.lambdatest.com/wd/hub"

Step 5: We then use the remote_url and browser capabilities to instantiate the corresponding browser (i.e. Chrome or Firefox)

Chrome

ch_driver = webdriver.Remote(
        command_executor=remote_url, desired_capabilities = ch_capabilities)

Firefox

ff_driver = webdriver.Remote(
        command_executor=remote_url, desired_capabilities = ff_capabilities)

Step 6: We then get the URL of the website on which we want to locate a specific element. In our test, we try to locate an element by its name and click on it. Once the element had been located and clicked, we quit the test.

Chrome

ch_driver.get('https://www.lambdatest.com/selenium-playground/')
    ch_driver.maximize_window()
    # Will find an element by its NAME property in the page and click it
    ch_driver.find_element(By.CLASS_NAME, "p-10").click()
    ch_driver.quit()

Firefox

ff_driver.get('https://www.lambdatest.com/selenium-playground/')
    # This will maximize the window interface of the driver class in this case it's FIREFOX
    ff_driver.maximize_window()
    # Will find an element by its NAME property in the page and click it
    ff_driver.find_element(By.CLASS_NAME, "p-10").click()
    ff_driver.quit()

Watch this video to learn exception handling in Selenium, which covers different types of exceptions and how to handle them using various methods.

Need a great solution for cross browser testing on Safari? Forget about emulators or simulators — use real online browsers. Try LambdaTest to test on Safari browser online!

NoSuchElementException Handling in Action

According to the exception mentioned above, we must catch “NoSuchElementException” and print the proper log messages to guarantee that our test fails with the proper error message.

We use the try and except method to catch the exception when it is raised in the test script. The “try” block lets you check the code for errors, while the “except” block lets you handle the errors or exceptions raised.

Chrome

import pytest
from selenium import webdriver
import sys
from selenium.webdriver.common.by import By
from selenium.common.exceptions import NoSuchElementException

ch_capabilities = {
        'LT:Options' : {
            "user" : "<username>",
            "accessKey" : "<accesskey>",
            "build" : "NoSuchElementException Test on Chrome",
            "name" : "NoSuchElementException Test on Chrome",
            "platformName" : "Windows 10"
        },
        "browserName" : "Chrome",
        "browserVersion" : "102.0",
    }

def test_lambdatest_nosuchelement():
    # LambdaTest Profile username
    user_name = "<username>"
    # LambdaTest Profile access_key
    app_key = "<accesskey>"
    # Remote Url to connect to our instance of LambdaTest
    remote_url = "https://" + user_name + ":" + app_key + "@hub.lambdatest.com/wd/hub"
    ch_driver = webdriver.Remote(
        command_executor=remote_url, desired_capabilities = ch_capabilities)
    ch_driver.get('https://www.lambdatest.com/selenium-playground/')
    ch_driver.maximize_window()
    try:
    # 'By' is used to locate the element by its property
        ch_driver.find_element(By.CLASS_NAME, "p-10")
        ch_driver.click()
    except NoSuchElementException:
        print("Exception Handled")

    ch_driver.quit()

Firefox

import pytest
from selenium import webdriver
import sys
from selenium.webdriver.common.by import By
from selenium.common.exceptions import NoSuchElementException

# Desired Capabilities according to SELENIUM 4
ff_capabilities = {
        'LT:Options' : {
            "user" : "<username>",
            "accessKey" : "<accesskey>",
            "build" : "NoSuchElementException Test for LambdaTest (Firefox)",
            "name" : "NoSuchElementException Test for LambdaTest (Firefox)",
            "platformName" : "Windows 10"
        },
        "browserName" : "Firefox",
        "browserVersion" : "101.0",
    }

def test_lambdatest_nosuchelement():
    # LambdaTest Profile username
    user_name = "<username>"
    # LambdaTest Profile access_key
    app_key = "<accesskey>"
    # Remote Url to connect to our instance of LambdaTest
    remote_url = "https://" + user_name + ":" + app_key + "@hub.lambdatest.com/wd/hub"
    # creating an instance of Firefox based on the remote url and the desired capabilities
    ff_driver = webdriver.Remote(
        command_executor=remote_url, desired_capabilities = ff_capabilities)
    ff_driver.get('https://www.lambdatest.com/selenium-playground/')
    # This will maximize the window interface of the driver class in this case it's FIREFOX
    ff_driver.maximize_window()
    try:
        # Will find an element by its NAME property in the page and click it
        ff_driver.find_element(By.CLASS_NAME, "p-10").click()
    except NoSuchElementException:
        print("Exception Handled")
    ff_driver.quit()

Execution:

Use the terminal to enter the following command to perform Selenium Python testing in parallel on the LambdaTest Grid.

poetry run pytest seltests/test_handle_nosuchelement_google.py 
seltests/test_handle_nosuchelement_firefox.py -n 2

The tests will be executed successfully.

The passed tests will be shown as follows in the LambdaTest Dashboard.

Code Walkthrough:

The “try” block will run the find_element() argument and take in the By query to locate an element using its name in the URL provided.

Step 1: In the browser’s inspect tool, click on Console and type the following command to find the element with the name “p-10”.

$x ("//*[text()='p-10']")

The test does not fail since the element with the name “p-10” does not exist. The “except” block will run, catching the exception.

Step 2: The try and except code block is the same in Chrome and Firefox text scripts.

Chrome

Firefox

StaleElementReferenceException

This exception is raised whenever an element is not present in the DOM or is deleted.

Scenario 1 (Chrome Browser)

Go to the URL link https://ecommerce-playground.lambdatest.io/index.php?route=account/login.
Find the reference to the email and password text fields.
Click on a link that reloads the entire web page.
Enter the password into the password field with the reference we located before the web page reloaded.

Scenario 2 (Firefox Browser)

Go to the URL link https://ecommerce-playground.lambdatest.io/index.php?route=account/login.
Find the reference to the email and password text fields.
Click on a link that reloads the entire web page.
Enter the password into the password field with the reference we located before the web page reloaded.

Implementation (Scenario 1 on the Chrome Browser):

FileName — test_staleelement_chrome.py

import pytest
from selenium import webdriver
import sys
from selenium.webdriver.common.by import By
from selenium.common.exceptions import StaleElementReferenceException


ch_capabilities = {
        'LT:Options' : {
            "user" : "<username>",
            "accessKey" : "<accesskey>",
            "build" : "StaleElementReferenceException Test on Chrome",
            "name" : "StaleElementReferenceException Test on Chrome",
            "platformName" : "Windows 10"
        },
        "browserName" : "Chrome",
        "browserVersion" : "102.0",
    }

def test_ecommerceplayground_staleelement():
     # LambdaTest Profile username
    user_name = "<username>"
    # LambdaTest Profile access_key
    app_key = "<accesskey>"
    # Remote Url to connect to our instance of LambdaTest
    remote_url = "https://" + user_name + ":" + app_key + "@hub.lambdatest.com/wd/hub"
    # creating an instance of Firefox based on the remote url and the desired capabilities
    ch_driver = webdriver.Remote(
        command_executor=remote_url, desired_capabilities = ch_capabilities)
    ch_driver.get('https://ecommerce-playground.lambdatest.io/index.php?route=account/login')

    emailElement = ch_driver.find_element(By.ID, "input-email")
    passwordElement = ch_driver.find_element(By.ID, "input-password")

    emailElement.send_keys("email@gmail.com")

    ch_driver.find_element(By.XPATH, "//input[@type='submit']").click()

    passwordElement.send_keys("password")

    ch_driver.quit()

Implementation (Scenario 2 on the Firefox Browser):

FileName — test_staleelement_firefox.py

import pytest
from selenium import webdriver
import sys
from selenium.webdriver.common.by import By
from selenium.common.exceptions import StaleElementReferenceException

# Desired Capabilities according to SELENIUM 4
ff_capabilities = {
        'LT:Options' : {
            "user" : "<username>",
            "accessKey" : "<accesskey>",
            "build" : "StaleElementReferenceException Test for LambdaTest (Firefox)",
            "name" : "StaleElementReferenceException Test for LambdaTest (Firefox)",
            "platformName" : "Windows 10"
        },
        "browserName" : "Firefox",
        "browserVersion" : "101.0",
    }


def test_ecommerceplayground_staleelement():
     # LambdaTest Profile username
    user_name = "<username>"
    # LambdaTest Profile access_key
    app_key = "<accesskey>"
    # Remote Url to connect to our instance of LambdaTest
    remote_url = "https://" + user_name + ":" + app_key + "@hub.lambdatest.com/wd/hub"
    # creating an instance of Firefox based on the remote url and the desired capabilities
    ff_driver = webdriver.Remote(
        command_executor=remote_url, desired_capabilities = ff_capabilities)
    ff_driver.get('https://ecommerce-playground.lambdatest.io/index.php?route=account/login')

    emailElement = ff_driver.find_element(By.ID, "input-email")
    passwordElement = ff_driver.find_element(By.ID, "input-password")

    emailElement.send_keys("email@gmail.com")

    ff_driver.find_element(By.XPATH, "//input[@type='submit']").click()

    passwordElement.send_keys("password")

    ff_driver.quit()

Execution:

Run the following command in the terminal to execute the test scripts in parallel testing.

poetry run pytest seltests/test_staleelement_google.py  seltests/test_staleelement_firefox.py

We receive a StaleElementExceptionError message in the terminal.

We can view the raised exceptions in the LambdaTest Dashboard.

Code Walkthrough:

Step 1: Import the necessary Selenium Python classes — pytest, webdriver, sys, By, and StaleElementReferenceException.

import pytest
from selenium import webdriver
import sys
from selenium.webdriver.common.by import By
from selenium.common.exceptions import StaleElementReferenceException

Step 2: We generate capabilities in the LambdaTest Capabilities based on the browser and OS.

Chrome

ch_capabilities = {
    'LT:Options': {
        "user": "<username>",
        "accessKey": "<accesskey>",
        "build": "StaleElementReferenceException Test on Chrome",
        "name": "StaleElementReferenceException Test on Chrome",
        "platformName": "Windows 10"
    },
    "browserName": "Chrome",
    "browserVersion": "102.0",
}

<pre>

<center><strong>Firefox</strong></center>

<pre>ff_capabilities = {
        'LT:Options' : {
            "user" : "<username>",
            "accessKey" : "<accesskey>",
            "build" : "StaleElementReferenceException Test for LambdaTest (Firefox)",
            "name" : "StaleElementReferenceException Test for LambdaTest (Firefox)",
            "platformName" : "Windows 10"
        },
        "browserName" : "Firefox",
        "browserVersion" : "101.0",
    }

Step 3: We create a function that will contain our test methods. In the function, we define the username and password for a remote_url that will connect to the Remote Selenium Grid.

def test_ecommerceplayground_staleelement():
    # LambdaTest Profile username
    user_name = "<username>"
    # LambdaTest Profile access_key
    app_key = "<accesskey>"
    # Remote Url to connect to our instance of LambdaTest
    remote_url = "https://" + user_name + ":" + \
        app_key + "@hub.lambdatest.com/wd/hub"
    # creating an instance of Chrome based on the remote url and the desired capabilities
    ch_driver = webdriver.Remote(
        command_executor=remote_url, desired_capabilities=ch_capabilities)
    ch_driver.get(
     'https://ecommerce-playground.lambdatest.io/index.php?route=account/login')

    emailElement = ch_driver.find_element(By.ID, "input-email")
    passwordElement = ch_driver.find_element(By.ID, "input-password")

    emailElement.send_keys("email@gmail.com")

    ch_driver.find_element(By.XPATH, "//input[@type='submit']").click()

    passwordElement.send_keys("password")

    ch_driver.quit()

The code for the browser tests is the same. We set the Chrome webdriver to ch_driver while the Firefox webdriver is ff_driver. Based on their ids, the emailElement variable will locate the email input element, while the passwordElement variable will locate the input element.

We then enter an email into the email input using the emailElement.send_keys() function and locate and click the login button, which is the type “submit”. Then enter the password and finally quit the test with the .quit() function.

When the code is run, a StaleElementReferenceException will be raised for the following reasons:

In Chrome, the element is not attached to the page document.
In Firefox, the element reference password is no longer attached to the DOM.

Code Walkthrough:

We apply the try and except code blocks to handle the “StaleElementReferenceException” when it is thrown during our test’s execution.

import pytest
from selenium import webdriver
import sys
from selenium.webdriver.common.by import By
from selenium.common.exceptions import StaleElementReferenceException

ch_capabilities = {
        'LT:Options' : {
            "user" : "<username>",
            "accessKey" : "<accesskey>",
            "build" : "Errors and Exceptions Test on Chrome",
            "name" : "Errors and Exceptions Test on Chrome",
            "platformName" : "Windows 10"
        },
        "browserName" : "Chrome",
        "browserVersion" : "102.0",
    }


def test_ecommerceplayground_staleelement():
     # LambdaTest Profile username
    user_name = "<username>"
    # LambdaTest Profile access_key
    app_key = "<accesskey>"
    # Remote Url to connect to our instance of LambdaTest
    remote_url = "https://" + user_name + ":" + app_key + "@hub.lambdatest.com/wd/hub"
    # creating an instance of Firefox based on the remote url and the desired capabilities
    ch_driver = webdriver.Remote(
        command_executor=remote_url, desired_capabilities = ch_capabilities)
    ch_driver.get('https://ecommerce-playground.lambdatest.io/index.php?route=account/login')

    emailElement = ch_driver.find_element(By.ID, "input-email")
    passwordElement = ch_driver.find_element(By.ID, "input-password")

    emailElement.send_keys("email@gmail.com")

    ch_driver.find_element(By.XPATH, "//input[@type='submit']").click()

    try:
        passwordElement.send_keys("password")

    except StaleElementReferenceException:
        print('StaleElementReferenceException handled')
        passwordElement = ch_driver.find_element(By.ID, "input-password")
        passwordElement.send_keys("password")

    ch_driver.quit()

The try block will run the code to add the password in which the exception will be raised. The except block will handle the exception by locating the password input element and sending the password value.

When the code is run, it will execute successfully in the terminal.

poetry run pytest seltests/test_handle_staleelement_google.py seltests/test_handle_staleelement_firefox.py

We can see successful test executions in the LambdaTest Build dashboard.

For a complete view of all test results and trends, check out your LambdaTest Analytics Dashboard. It lets you see how the tests are moving along, so you can make sure that everything is executed accordingly.

Test your native, hybrid, and web apps across all legacy and latest mobile operating systems on the most powerful Online emulator Android.

Conclusion

In this blog, we have looked at some common exceptions in Selenium Python. We have also deep-dived into various exceptions and looked at why NoSuchElementException and StaleElementReference are generated and how to handle them. Selenium Python provides methods using which you can handle various exceptions, and in this case, we have focused on the try and except method.

How To Handle Multiple Windows In Selenium Python

EugeneKwaka — Wed, 30 Nov 2022 14:15:46 +0000

Automating testing is a crucial step in the development pipeline of a software product. In an agile development environment, where there is continuous development, deployment, and maintenance of software products, automation testing ensures that the end software products delivered are error-free.

In the world of automation, Selenium is one of the most widely used open-source automation testing frameworks to execute automated web browser tests on websites. Selenium can run automated tests on various browsers (e.g., Chrome, Firefox, Edge, etc.). The test automation scripts can be devised using popular frameworks offered by languages like C#, Java, JavaScript, Python, and more.

The automated test cases you perform using Selenium might lead you to instances where it is necessary to handle multiple windows while working with a web application. This situation may arise as a result of clicking a button on the website that opens up a URL to a new tab or a new window. For example, the job search platform Glassdoor opens a new window when you click the buttons to sign in using your Google account or Facebook account.

Click on the “Continue with Facebook” button to sign in.

A Facebook webpage window will pop up to prompt you to sign in.

As a result, the user might need to access the open browser window to move forward.

As a QA tester, running a test case might require you to complete some operations in a newly opened browser window or tab before going back to the original window or tab to finish the rest of the tasks.

In this blog on how to handle multiple windows in Selenium Python, we will discuss the basics of browser windows and how to handle multiple windows in Selenium Python. By the end of the blog, you will be able to handle multiple windows when they arise when executing test cases.

Learn what Selenium is and its benefits for automated cross browser testing. See how Selenium works and get ready to use it for testing. Read more.

What is a Browser Window in Selenium?

A browser window, also known as the main window or parent window, is the handle of the homepage or current open webpage that a user lands on after accessing a browser. Upon running a Selenium automation script, the parent window will launch. Creating a Selenium WebDriver session opens up a window that is, by default, under the WebDriver’s control.

To have a view of what a parent window looks like, here is a window of the LambdaTest Selenium Playground website.

Selenium WebDriver always keeps the context of the parent window when navigating to a defined URL that opens a new window. The child window will be within the context of the parent window. This enables navigating back and forth between the windows once you are done with the operations you were handling in the newly opened child window.

This was all about the browser window in Selenium. In the next section of this blog on how to handle multiple windows in Selenium Python, we will learn more about child windows in Selenium.

Are you using Playwright for automation testing? Run your Playwright test scripts instantly on 50+ browser/OS combinations using the LambdaTest cloud. Sign up for free!

What is a Child Window in Selenium?

When we click on a button or URL link in the parent window, and the action opens another window(s) within the main window, the new window(s) is called a child window. The new window(s) or tab(s) opened are called children of the parent window and have unique window handles.

To demonstrate the handling of child windows, let’s use the LambdaTest Selenium Playground we mentioned earlier:

1- Click on the Windows Popup Modal link in the main window.

2- Click on the buttons in the Single Window Popup Modal to open a single child window.

3- Click on the Multiple Window Popup buttons to open multiple child browser windows. The first button opens two child windows, while the “Follow All” button opens three child windows.

The current page you are on is the main window, while the windows (Facebook, Twitter, and LambdaTest web pages) open by clicking the buttons are the child windows.

It is possible to open a single window or multiple child windows from a single main window. It is also important to note that a child window may or may not contain a URL link.

While conducting a test case on the above scenario manually, it is simple to examine the behavior of the child windows because of their visibility in the context of the parent window. However, this is not the case when using Selenium to automate the test case because we need to change the WebDriver’s context from the parent window to the child window to perform actions on it.

A comprehensive End to End testing tutorial that covers what E2E Testing is, its importance, benefits, and how to perform it with real-time examples.

What is a Window Handle in Selenium Python?

Since we have discussed the concept of windows in Selenium in the above section of this blog on how to handle multiple windows in Selenium Python, let us move on to learning how to control multiple windows.

Multiple windows are brought up by scenarios in which a web application navigates to or opens multiple browser windows. Selenium provides the option to handle multiple windows with window handles.

The Selenium WebDriver does not distinguish between windows and tabs. It handles both using window handles. Whenever a window is opened, it contains a distinct ID that returns a string value, making it unique and persisting for the entire session.

Using the Window Popup Modal Demo page from the LambdaTest Selenium Playground website, we can see the IDs of the main browser window and the child window, as shown below.

How to handle multiple windows in Selenium Python?

We can handle the occurrence of child windows or tabs when running test cases using Selenium Python. When a parent window opens a child window, the WebDriver only controls one window at a time in the running session.

The WebDriver controls the main window, and any actions in a test script will be executed in the currently active window.

The Selenium Python WebDriver provides the following methods to handle multiple windows.

current_window_handle()

This method collects the unique window handle ID of the browser window that is currently active.

Syntax: driver.current_window_handle

window_handles()

This method returns the IDs of all the windows that have been opened by the WebDriver in the current session. It stores the window IDs to be used for switching windows.

Syntax: driver.window_handles

switch_to.window()

This method switches the WebDriver’s focus from the currently open browser window to the intended browser window. The targeted window’s id is passed as the argument to shift the WebDriver’s control to the new window.

Syntax:

Option 1: driver.switch_to.window()

Option 2: driver.switch_to.window()

Now, let’s deep dive into it with a practical demonstration on how to handle multiple windows in Selenium Python.

Perform browser automation testing on the most powerful cloud infrastructure. Leverage LambdaTest Automation testing platform for faster, reliable and scalable experience on cloud.

Demonstration: How to handle multiple windows in Selenium Python?

Now that we have looked at the different methods available in Selenium Python to handle multiple windows, this section on how to handle multiple windows in Selenium Python looks at how to execute these Selenium tests on a cloud Selenium Grid.

The best approach to fully utilizing Python automation testing and achieving the intended results quickly is to use a cloud-based Selenium Grid. We can automate multiple window handling in Selenium Python using a cloud-based Selenium Grid platform like LambdaTest.

LambdaTest enables you to perform automated cross browser testing at scale using a Selenium IDE cloud. The platform offers an online browser farm of 3000+ real web browsers running on various operating systems to ensure that enterprises develop more high-quality software applications faster.

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around automated browser testing, Selenium testing, Cypress E2E testing, CI/CD, and more.

Accelerate your release velocity with blazing fast test automation cloud!

Project Setup

To get started writing tests for Python web automation, we need to have Python and Selenium installed on the client machine. If you are unfamiliar with Selenium using Python, you can check out this detailed blog on getting started with Selenium Python.

There are many different Python testing frameworks available for Selenium testing, including PyUnit (unittest), pytest, Behave, Robot, Lettuce, Nose2, and Testify. You can learn more about these Selenium Python testing frameworks in detail in this blog post on the best Python testing frameworks.

In this blog on how to handle multiple windows in Selenium Python, however, we will use the pytest testing framework. Pytest is an open-source Python web automation framework mainly used for unit testing and is scalable by supporting automation tests for functions, APIs, and unit tests.

This detailed Selenium pytest tutorial can teach you more about how to configure and begin using the pytest Framework to perform automated tests in Selenium Python.

We use VS Code(Visual Studio ) IDE to write and run the Selenium Python automation scripts for our test case project. Apart from VS Code, there are other IDEs available such as Atom, PyCharm, and Sublime Text that can be used to write the test scripts as well.

The package manager we use is PIP, the default package manager for Python. It comes preinstalled when you install Python (version 3.4 and above). Pip allows you to install and manage additional packages that aren’t included in the Python standard library. These packages are built specially to be used for different development frameworks, utilities, and modules.

The test case project’s demonstration will be run on a Windows operating system. In addition, steps on how to set up the project on a macOS have also been included.

1- To use Pip to manage our project’s dependencies, let us first look at the version currently available in the command-line terminals

Windows: pip –version

macOS: pip –version

2- Create a directory that will hold the test project.

3- Move into the project folder you have just created.

4- Create a virtual environment (venv) that will hold the specific dependencies used by the test project. The creation of a venv is crucial because we do not want to combine the global dependencies provided by Python with the particular libraries we need to run the project’s test cases. We install the virtual environment library on Windows to help create the venv using the following command.

Windows:

macOS: sudo pip install virtualenv

5- Run the below-mentioned command on the terminal to activate the virtual environment.

Windows:

macOS: virtualenv multiplewindowstest

6- Activate the virtual environment so we can install the required libraries to run our test project.

macOS: source multiplewindowstest/bin/activate

7- We install the following library dependencies in our test project’s venv to run the Selenium Python tests:

selenium (v 4.1.2)
flake8 (v 4.0.1)
pytest (v 7.1.2)
pytest-xdist (v 2.5.0)
autopep8 (v 1.6.0)

The autopep8 library enforces the PEP 8 style manual on the Python code to ensure it is in the correct format, while flake8 is a library that tests the Python code for errors that are against the PEP 8 style guide.

The pytest-xdist plugin is an extension of pytest that introduces a new test execution mode that enables us to perform parallel Selenium Python tests.

1- To install the dependencies described above, write the command below in the terminal as follows.

Syntax — pip install [library name]

2- Create a “requirements.txt” file that contains all the installed project dependencies in the root folder.

pip freeze >requirements.txt

autopep8==1.6.0
flake==4.0.1
pytest==7.1.2
pytest-forked==1.4.0
pytest-xdist==2.5.0
selenium==4.1.2

Let’s create a folder called “seltests” in the project’s root directory to house the test scripts.

Before running the tests, please set the environment variables LT_USERNAME & LT_ACCESS_KEY from the terminal. The account details are available on the LambdaTest Profile page.

For macOS:

export LT_USERNAME=LT_USERNAME
export LT_ACCESS_KEY=LT_ACCESS_KEY

For Linux:

export LT_USERNAME=LT_USERNAME
export LT_ACCESS_KEY=LT_ACCESS_KEY

For Windows:

set LT_USERNAME=LT_USERNAME
set LT_ACCESS_KEY=LT_ACCESS_KEY

In the next sections of this blog on how to handle multiple windows in Selenium Python, we will look into the following use cases while handling windows in Selenium Python:

Handling a single child window in Selenium Python
Handling multiple child windows in Selenium Python
Switching back to a parent window from a child window in Selenium Python

Need a great solution for Safari for Windows? Forget about emulators or simulators — use real online browsers. Try LambdaTest for free!

Handling a single child window in Selenium Python

Let us look at how to implement window handling on a single child window in the following test case scenario.

Test Case:

1- Navigate to the URL link https://www.lambdatest.com/selenium-playground/.

2- Click on the “Window Popup Modal” link.

3- In the new webpage, click on the “Follow on Twitter” button to open a child window.

4- Switch to the child window opened.

5- Print the window handle id of the child window.

Implementation (Test Case on the Chrome Browser):

import os
import pytest
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options as ChromeOptions

def test_single_window_chrome():
    options = ChromeOptions()
    options.browser_version = '103.0'
    options.platform_name = 'Windows 10'
    lt_options = {}
    lt_options['username'] = os.environ.get ('LT_USERNAME')
    lt_options['accesskey'] = os.environ.get ('LT_ACCESS_KEY')
    lt_options['project'] = 'SingleWindowHandling'
    lt_options['selenium_version'] = '4.1.2'
    lt_options['w3c'] = True
    options.set_capability('LT:options', lt_options)
    # LambdaTest Profile username
    user_name = os.environ.get('LT_USERNAME')
    # LambdaTest Profile access_key
    accesskey = os.environ.get('LT_ACCESS_KEY')
    remote_url = "https://" + user_name + ":" + \
        accesskey + "@hub.lambdatest.com/wd/hub"
    driver = webdriver.Remote(remote_url, options=options)
    driver.get('https://www.lambdatest.com/selenium-playground')
    driver.maximize_window()
    # Look for the window popup modal link and click
    element = WebDriverWait(driver, 3).until(EC.element_to_be_clickable((By.CSS_SELECTOR, 'a[href="https://www.lambdatest.com/selenium-playground/window-popup-modal-demo"]')))
    element.click()
    # Get the window handle Id of the current parent window
    parent_guid = driver.current_window_handle
    print(f"The parent window guid is: {parent_guid}")
    twitter_element = WebDriverWait(driver, 3).until(EC.element_to_be_clickable((By.CSS_SELECTOR, 'a[title="Follow @Lambdatesting on Twitter"]')))
    twitter_element.click()
    # Get the window handle ids of all the windows opened
    all_guid = driver.window_handles
    # iterate through the guids and if there is a parent window id skip it and switch to the new window
    for guid in all_guid:
        if guid != parent_guid:
            driver.switch_to.window(guid)
            print(f"The child guid is: {guid}")
            driver.close()

    driver.quit()

Code Execution:

To run the test scripts, type the following command in the terminal.

python -m pytest seltests/test_single_window_handling_chrome.py

Once the test is executed, the output in the terminal will display the GUIDS of the parent and child windows, as shown below.

After the test execution is completed, you can view the results and logs in the Build section of the LambdaTest Automation Dashboard.

You can view a test recording and logs of the tests executed.

Code Walkthrough:

Now, let us go through the code we have written in detail.

Step 1: Here, we import the important Selenium Python libraries that will enable us to perform our test. These include pytest, WebDriver, By, BrowserOptions, WebDriverWait, and expected_conditions.

We import pytest, as it is Selenium Python’s primary unit testing tool. The imported Selenium WebDriver is a web framework that automates cross browser tests.

The By query is used to locate specific web elements using the find_element() method. The explicit wait time implements the WebDriverWait class combined with the expected_conditions class to define the wait for a certain condition to be executed before proceeding to the next part of the code.

Lastly, the Options class customizes the specified browser driver sessions. For this instance, we are using the ChromeOptions classes.

Step 2: We generate options using the LambdaTest Automation Capabilities Generator according to the browser we use to run the automated tests. We create an instance of the Options class, set the conditions, and pass it to the driver constructor.

Step 3: We set the username and accesskey provided in the LambdaTest Profile page to a remote_url variable that connects us to the Remote Selenium Grid (@hub.lambdatest.com/wd/hub). We then use the remote_url and options to instantiate the corresponding web browser (Chrome).

Step 4: We open the LambdaTest Playground website, then maximize the browser window to locate the web element with the link to the Window Popup Demo Page.

Right-click the “Windows Popup Modal” link and click inspect to open the browser inspect tool. The web element is located using its href tag.

We use the driver. current_window_handle method to obtain the parent window’s unique id and store it as a string.

Step 5: We then locate the web element with the button “Follow on Twitter” using its title and click on it to open a child window.

We store the window handles of the opened windows in a variable called all_guid.

Step 6: We then switch to the child window using the driver.switch_to.window(guid) method. The code iterates through the stored window handles, and if it comes across the parent window handle, it skips over it and switches to the child window. Then the child window’s ID is printed.

The driver.close() method closes the currently active child window and will quit the driver session if the child window is the only active window.

We then close the browser session using the driverquit() method in Selenium.

Do you use a Mac and want to run the test in Internet Explorer? This article explores how to test Internet explorer for Mac.

Handling multiple child windows in Selenium Python

In the above section of this blog on how to handle multiple windows in Selenium Python, we have looked at how to handle a single child window in Selenium using Python. Let us go through how to implement window handling of multiple child windows in the scenarios below.

Test Case (Switch Window by Page Title)

1- Navigate to the URL https://www.lambdatest.com/selenium-playground/.

2- Click on the “Window Popup Modal’ link.

3- In the new webpage, click on the “Follow Twitter & Facebook” button to open the child windows.

4- Switch to each open child window using the page titles.

5- Print the page title of each of the child windows.

6- Close the browser session.

 import os
    import pytest
    from selenium import webdriver
    from selenium.webdriver.common.by import By
    from selenium.webdriver.chrome.options import Options as ChromeOptions
    from selenium.webdriver.support.ui import WebDriverWait
    from selenium.webdriver.support import expected_conditions as EC

    def test_multiple_windows_chrome():
        options = ChromeOptions()
        options.browser_version = '103.0'
        options.platform_name = 'Windows 10'
        lt_options = {}
        lt_options['username'] = os.environ.get ('LT_USERNAME')
        lt_options['accesskey'] = os.environ.get ('LT_ACCESS_KEY')
        lt_options['project'] = 'Multiple Window Handling Test'
        lt_options['selenium_version'] = '4.0.0'
        lt_options['w3c'] = True
        options.set_capability('LT:options', lt_options)
        # LambdaTest Profile username
        user_name = os.environ.get ('LT_USERNAME')
        # LambdaTest Profile access_key
        accesskey = os.environ.get ('LT_ACCESS_KEY')
        remote_url = "https://" + user_name + ":" + \
            accesskey + "@hub.lambdatest.com/wd/hub"
        driver = webdriver.Remote(remote_url, options=options)
        driver.get('https://www.lambdatest.com/selenium-playground')
        driver.maximize_window()
        # Look for the window popup modal link and click
        element = WebDriverWait(driver, 3).until(EC.element_to_be_clickable((By.CSS_SELECTOR, 'a[href="https://www.lambdatest.com/selenium-playground/window-popup-modal-demo"]')))
        element.click()
        # Get the window handle Id of the current parent window
        parent_guid = driver.current_window_handle
        parent_title = driver.title
        print(f"The parent window name is {parent_title} and its handle is: {parent_guid}")
        # Locate and click on the button "Follow Twitter & Facebook"
        web_element = WebDriverWait(driver, 3).until(EC.element_to_be_clickable((By.ID, 'followboth')))
        web_element.click()
        # Get the window handle ids of all the windows opened
        all_guid = driver.window_handles
        # Get the total number of windows of the open
        num_of_handles = len(all_guid)
        # print the numbers of window open
        print(f"The number of windows open {num_of_handles} ")

        # iterate through the total number of guids and if there is a parent window id skip it and switch to the new child windows
        for num in range(num_of_handles):
            if all_guid[num] != parent_guid:
                driver.switch_to.window(all_guid[num])
                print(f"The child window's title is: {driver.title}")
                driver.close()

        driver.quit()

Code Execution:

We execute the test scripts in the terminal using the following command.

python -m pytest seltests/test_multiple_windows_handling_chrome.py

The test runs successfully in the terminal and displays the following output, as shown below.

We can view the test script’s results in the LambdaTest Builds section.

The test’s logs and recordings are also displayed.

Code Walkthrough:

The code written for implementing multiple child window handling in Selenium using Python is similar to that written for handling a single child window. Nonetheless, the difference comes when iterating through the window handles, as we show the distinction between the child windows based on their respective page titles.

In the “Window Popup Modal” page, we locate the “Follow Twitter & Facebook” button using its ID in the inspect tool. We click the button, which will then open up two child windows.

The window handles of the currently open windows are stored in a variable called all_guid, and the total number of open windows is captured in the variable num_of_handles.

The code iterates through all the window handles stored, identifies the child window handles, and switches to the child windows. The code checks the page title of the child window and prints it. The child windows are then closed using the driver.close() method.

The driver session is then finally closed using the quit() method.

Online web testing on a cloud platform. Get instant access of Browsers like Safari, Chrome, Firefox, Opera, Yandex. 3000+ desktop & mobile environments. Be it automation testing or real time testing, we got you covered. Try for free!

Switching back to a parent window from a child window in Selenium Python

Let us look at a scenario where we want to switch back to the parent window from the child window after we have completed some operations. This means we must change the WebDriver’s control to the main window.

We will implement the scenario discussed in the above section of this blog on how to handle multiple windows in Selenium Python to demonstrate switching back to the parent window.

    import os
    import pytest
    from selenium import webdriver
    from selenium.webdriver.common.by import By
    from selenium.webdriver.chrome.options import Options as ChromeOptions
    from selenium.webdriver.support.ui import WebDriverWait
    from selenium.webdriver.support import expected_conditions as EC

    def test_switch_to_parent_window_chrome():
        options = ChromeOptions()
        options.browser_version = '103.0'
        options.platform_name = 'Windows 10'
        lt_options = {}
        lt_options['username'] = os.environ.get ('LT_USERNAME')
        lt_options['accesskey'] = os.environ.get ('LT_ACCESS_KEY')
        lt_options['project'] = 'Switch Back To Parent Window Test'
        lt_options['selenium_version'] = '4.0.0'
        lt_options['w3c'] = True
        options.set_capability('LT:options', lt_options)
        # LambdaTest Profile username
        user_name = os.environ.get ('LT_USERNAME')
        # LambdaTest Profile access_key
        accesskey = os.environ.get ('LT_ACCESS_KEY')
        remote_url = "https://" + user_name + ":" + \
            accesskey + "@hub.lambdatest.com/wd/hub"
        driver = webdriver.Remote(remote_url, options=options)
        driver.get('https://www.lambdatest.com/selenium-playground')
        driver.maximize_window()
        # Look for the window popup modal link and click
        element = WebDriverWait(driver, 3).until(EC.element_to_be_clickable((By.CSS_SELECTOR, 'a[href="https://www.lambdatest.com/selenium-playground/window-popup-modal-demo"]')))
        element.click()
        # Get the window handle Id of the current parent window
        parent_guid = driver.current_window_handle
        print(f"The Parent Window guid is: {parent_guid}")
        # Locate and click on the button "Follow Twitter & Facebook"
        web_element = WebDriverWait(driver, 3).until(EC.element_to_be_clickable((By.ID, 'followboth')))
        web_element.click()
        # Get the window handle ids of all the windows opened
        all_guid = driver.window_handles
        # Get the total number of windows of the open
        num_of_handles = len(all_guid)
        # print the numbers of window open
        print(f"The number of windows open {num_of_handles} ")

        # iterate through the total number of guids and if there is a parent window id skip it and switch to the new child windows
        for num in range(num_of_handles):
            if all_guid[num] != parent_guid:
                driver.switch_to.window(all_guid[num])
                print(f"The child window's title is: {driver.title}")
                driver.close()

        # Switch back to parent window
        driver.switch_to.window(parent_guid)
        print(f"The parent guid is: {parent_guid}")
        driver.quit()

Code Execution:

We run the test script in the terminal using the following command.

python -m pytest seltests/test_switch_to_parent_window_chrome.py

The test script will execute successfully in the terminal and display the following output.

We can view the test results in the LambdaTest Builds dashboard.

Code Walkthrough:

In the test script, after navigating through the child windows and performing the operations we specified in the scenario before, the open child windows are closed. We then switch back to the parent window using the switch_to.window(parent_guid) method with the parent_guid variable as the method’s argument. We then print the parent window’s handle.

The driver session is finally closed using the driver.quit() method.

If you are a Python programmer looking to take your career to the next level, you can go with the Selenium Python 101 certification from LambdaTest.

Upload your app for testing within seconds using the LambdaTest cloud and perform mobile app testing right away. Find bugs early on, improve performance, quality, user experience and make the most of mobile app test on LambdaTest.

Conclusion

In this Selenium Python tutorial, we have covered in detail what windows are and how to handle multiple windows when they occur in testing using Selenium Python. We have looked at the two types of windows — the parent window and the child window. We have written test scripts that implement window handling for a single child window and multiple child windows. We have also looked at how to switch back to the parent window after completing operations on the child windows.

I hope this blog on how to handle multiple windows in Selenium Python will help you while performing test automation.