Keyboard Action in Python Selenium

by

Introduction to Keyboard Actions in Selenium

When automating web applications with Python Selenium, handling keyboard interactions is crucial for testing scenarios like filling forms, simulating keypresses, and navigating applications. Selenium provides robust functionalities to simulate user interactions with a keyboard using the ActionChains class and send_keys method.

Import Required Modules

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.action_chains import ActionChains

Using send_keys to Simulate Typing

The send_keys method allows us to send keyboard inputs to elements like text fields.

Example: Entering Text in a Textbox

# Launch browser
driver = webdriver.Chrome()
driver.get("https://facebook.com")

# Locate the input field
input_field = driver.find_element("name", "username")

# Simulate typing
input_field.send_keys("TestUser")

Keyboard Shortcuts Using Keys Class

Selenium provides the Keys class to simulate keyboard shortcuts like CTRL+C, CTRL+V, ENTER, and more.

Example: Pressing ENTER Key

input_field.send_keys(Keys.ENTER)

Example: Copy-Paste Using Keyboard Shortcuts

input_field.send_keys("Test")
input_field.send_keys(Keys.CONTROL, 'a')  # Select all
input_field.send_keys(Keys.CONTROL, 'c')  # Copy
input_field.send_keys(Keys.TAB)  # Move to next field
input_field.send_keys(Keys.CONTROL, 'v')  # Paste

Using ActionChains for Complex Keyboard Actions

ActionChains helps perform multiple actions, including pressing and releasing keys.

Example: Using ActionChains for Keyboard Events

# Create ActionChains instance
actions = ActionChains(driver)

# Locate element
element = driver.find_element("id", "search")

# Perform actions
actions.click(element)
actions.send_keys("Selenium Automation")
actions.send_keys(Keys.RETURN)
actions.perform()

Handling Special Keys

Some keys like BACKSPACE, DELETE, ESC, F1-F12, SHIFT, ALT, CONTROL are essential in automation.

Example: Using Special Keys

input_field.send_keys(Keys.BACKSPACE)  # Deletes last character
input_field.send_keys(Keys.ESCAPE)  # Simulates ESC key

Pressing and Holding Keys

Pressing and holding keys like SHIFT allows us to capitalize text or perform shortcuts.

Example: Holding SHIFT Key

actions.key_down(Keys.SHIFT).send_keys("selenium").key_up(Keys.SHIFT).perform()

Using send_keys_to_element Method

Instead of sending keys directly, send_keys_to_element allows targeted input.

Example: Sending Keys to Specific Element

from selenium.webdriver.common.actions.action_builder import ActionBuilder

action = ActionBuilder(driver)
action.send_keys_to_element(input_field, "Automated Text").perform()

Automating Login Forms Using Keyboard Actions

Example: Automating Login with Keyboard Inputs

driver.get("https://facebook.com/login")

# Locate fields
username = driver.find_element("name", "username")
password = driver.find_element("name", "password")

# Type credentials
username.send_keys("testuser")
password.send_keys("securepassword")
password.send_keys(Keys.RETURN)  # Press Enter

Handling Alerts and Popups Using Keyboard Keys

Example: Closing an Alert Using ESC

alert = driver.switch_to.alert
actions.send_keys(Keys.ESCAPE).perform()
<< Previous

Chrome Options in Python Selenium

by

Introduction to Chrome Options in Selenium

Chrome options in Python Selenium play a crucial role in configuring and customizing the Chrome browser for automation tasks. By utilizing ChromeOptions, testers and developers can enhance their browser automation scripts by enabling or disabling certain features, managing extensions, controlling headless browsing, and much more.

Setting Up ChromeOptions in Selenium

To begin using ChromeOptions, we must import the required modules and instantiate the WebDriver with custom options. Below is a basic implementation:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

# Instantiate ChromeOptions
chrome_options = Options()

# Initialize WebDriver with options
driver = webdriver.Chrome(options=chrome_options)

This code initializes the Chrome browser with default settings. However, we can add multiple options to configure the browser according to our needs.

Commonly Used ChromeOptions in Selenium

1. Running Chrome in Headless Mode

Headless mode runs Chrome without a visible UI, making tests faster and more efficient:

chrome_options.add_argument("--headless")
driver = webdriver.Chrome(options=chrome_options)

This is particularly useful for continuous integration (CI) pipelines where a graphical interface is unnecessary.

2. Disabling Browser Notifications

To prevent pop-up notifications from interrupting automation tests:

chrome_options.add_argument("--disable-notifications")

3. Running Selenium in Incognito Mode

To launch Chrome in incognito mode for testing privacy-related functionalities:

chrome_options.add_argument("--incognito")

4. Disabling GPU Acceleration

In some cases, GPU acceleration may cause issues. We can disable it as follows:

chrome_options.add_argument("--disable-gpu")

5. Maximizing the Browser Window

To start Chrome with a maximized window:

chrome_options.add_argument("--start-maximized")

6. Running Chrome with a Custom User-Agent

To simulate different browsers and devices, we can set a custom User-Agent:

user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
chrome_options.add_argument(f"--user-agent={user_agent}")

7. Using a Specific Proxy

To route browser traffic through a proxy:

proxy = "http://your.proxy.server:port"
chrome_options.add_argument(f"--proxy-server={proxy}")

8. Disabling Extensions

To launch Chrome without loading any installed extensions:

chrome_options.add_argument("--disable-extensions")

Advanced ChromeOptions Configurations

1. Adding Experimental Options

Chrome provides experimental options that can be enabled via ChromeOptions:

prefs = {"profile.default_content_setting_values.cookies": 2}  # Block cookies
chrome_options.add_experimental_option("prefs", prefs)

2. Using Prefers Reduced Motion Setting

To disable animations for improved performance:

chrome_options.add_experimental_option("prefs", {"profile.managed_default_content_settings.images": 2})

3. Specifying the Chrome Binary Path

If Chrome is installed in a non-standard location:

chrome_options.binary_location = "/path/to/chrome"

4. Capturing Browser Console Logs

For debugging JavaScript errors, we can enable logging:

from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
capabilities = DesiredCapabilities.CHROME.copy()
capabilities["goog:loggingPrefs"] = {"browser": "ALL"}
driver = webdriver.Chrome(desired_capabilities=capabilities, options=chrome_options)

Integrating ChromeOptions with Selenium WebDriver

Here’s a complete example demonstrating multiple ChromeOptions:
from selenium import webdriver
from selenium.webdriver.chrome.options import Options

chrome_options = Options()
chrome_options.add_argument("--headless")
chrome_options.add_argument("--disable-gpu")
chrome_options.add_argument("--window-size=1920x1080")
chrome_options.add_argument("--disable-notifications")
chrome_options.add_argument("--no-sandbox")

# Initialize WebDriver
driver = webdriver.Chrome(options=chrome_options)
driver.get("https://www.facebook.com")

print(driver.title)
driver.quit()
<< Previous
Next >>

Headless Mode Execution in Python Selenium

by

Introduction to Headless Mode in Selenium

While Selenium can execute scripts with a visible browser window, headless execution allows tests to run in the background, significantly improving performance and efficiency.

Headless mode is particularly useful for environments where GUI is not required, such as server-side automation, continuous integration (CI/CD) pipelines, and web scraping. This article provides a comprehensive guide on how to execute Selenium scripts in headless mode using Python.

Why Use Headless Mode in Selenium?

There are several benefits to using headless mode in Selenium:

  • Increased Performance: Without rendering a UI, execution is faster and consumes fewer system resources.
  • Automation in Non-GUI Environments: Essential for running tests on headless servers.
  • Enhanced Stability in CI/CD Pipelines: Minimizes issues related to UI rendering.
  • Faster Web Scraping: Extracts data from websites efficiently without opening a visible browser window.

Setting Up Selenium for Headless Execution

Before running Selenium in headless mode, ensure you have the following installed:

Headless Mode Execution with Chrome

Google Chrome supports headless execution natively. Below is how you can configure Selenium with Chrome in headless mode:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

# Set up Chrome options
chrome_options = Options()
chrome_options.add_argument("--headless")  # Enable headless mode
chrome_options.add_argument("--disable-gpu")  # Recommended for Windows OS
chrome_options.add_argument("--window-size=1920x1080")  # Set window size

driver = webdriver.Chrome(options=chrome_options)

# Open a website
driver.get("https://www.facebook.com")
print(driver.title)

# Close the browser
driver.quit()

Headless Mode Execution with Firefox (GeckoDriver)

For Mozilla Firefox, you need to set the headless argument:

from selenium import webdriver
from selenium.webdriver.firefox.options import Options

# Set up Firefox options
firefox_options = Options()
firefox_options.add_argument("--headless")

driver = webdriver.Firefox(options=firefox_options)

# Open a website
driver.get("https://www.facebook.com")
print(driver.title)

# Close the browser
driver.quit()

Running Selenium in Headless Mode with Different Browsers

Apart from Chrome and Firefox, Selenium also supports headless execution with other browsers like Edge and Opera. Here’s how you can configure them:

Microsoft Edge (Chromium-based)

from selenium import webdriver
from selenium.webdriver.edge.options import Options

edge_options = Options()
edge_options.add_argument("--headless")
driver = webdriver.Edge(options=edge_options)

# Open a website
driver.get("https://www.facebook.com")
print(driver.title)

# Close the browser
driver.quit()

Taking Screenshots in Headless Mode

Even though the browser is running in headless mode, you can still capture screenshots:

driver.save_screenshot("screenshot.png")

Best Practices for Running Selenium in Headless Mode

  • Always set a window size: Some elements may not load correctly without a defined viewport.
  • Use explicit waits: JavaScript-heavy pages require WebDriverWait.
  • Handle exceptions: Use try-except to manage errors efficiently.
  • Use logging: Monitor script behavior with logging.
  • Update drivers: Ensure compatibility with the latest browser versions.
<< Previous
Next >>

How to Scroll to an Element in Python Selenium

by

Introduction to Scrolling in Selenium with Python

When dealing with web pages, there are instances where elements are not immediately visible due to scrolling. In such cases, scrolling to a specific element ensures that Selenium can interact with it properly. This guide will cover the most effective techniques for scrolling to an element using Python Selenium.

Methods to Scroll to an Element in Selenium

1. Using JavaScript Execution

One of the most reliable ways to scroll to an element in Selenium is by executing JavaScript commands. JavaScript’s scrollIntoView() method is effective for scrolling directly to an element.

Example:

from selenium import webdriver
from selenium.webdriver.common.by import By
import time

# Initialize the WebDriver
driver = webdriver.Chrome()

# Open a webpage
driver.get("https://facebook.com")

# Locate the element to scroll to
element = driver.find_element(By.ID, "target-element")

# Scroll to the element using JavaScript
driver.execute_script("arguments[0].scrollIntoView();", element)

# Pause for visibility
time.sleep(2)

# Close the driver
driver.quit()

Explanation:

  • execute_script(“arguments[0].scrollIntoView();”, element):
    This command ensures the element is brought into view.
  • This method works in most scenarios and is highly effective for ensuring elements are interactable.

2. Using ActionChains for Smooth Scrolling

ActionChains in Selenium provides a human-like scrolling experience, ensuring smooth interactions with dynamically loaded elements.

Example:

from selenium.webdriver.common.action_chains import ActionChains

# Initialize ActionChains
actions = ActionChains(driver)

# Move to the element
actions.move_to_element(element).perform()

Why Use ActionChains?

  • Useful for hover effects and dynamically loaded content.
  • Provides a natural user interaction simulation.

3. Using the scrollBy Method

Another JavaScript-based approach involves scrolling by a specific pixel value.

Example:

driver.execute_script("window.scrollBy(0, 500);")

When to Use scrollBy?

  • When you need incremental scrolling.
  • Useful when you don’t have direct access to the element.

4. Using scrollTo for Absolute Positioning

To scroll to an exact position on a page, use window.scrollTo().

Example:

driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")

Best Use Case:

  • When you need to scroll to the bottom of a webpage.
  • Useful for infinite scrolling pages (e.g., social media feeds).

Handling Scroll with Dynamic Content

Some pages load elements dynamically, requiring additional wait time before interacting with elements. The best approach is to use WebDriverWait to ensure elements are visible before scrolling.

Example:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Wait until the element is present
wait = WebDriverWait(driver, 10)
element = wait.until(EC.presence_of_element_located((By.ID, "target-element")))

# Scroll to the element
driver.execute_script("arguments[0].scrollIntoView();", element)

Why Use WebDriverWait?

  • Ensures elements are loaded before interaction.
  • Avoids unnecessary NoSuchElementException errors.

Best Practices for Scrolling in Selenium

To ensure smooth scrolling in Selenium:

  • Use JavaScript execution (scrollIntoView()) for reliability.
  • Use ActionChains when interacting with dynamic elements.
  • Implement WebDriverWait to handle elements that load asynchronously.
  • Test across different browsers to ensure compatibility.
<< Previous
Next >>

Execute JavaScript in Python Selenium

by

Selenium is one of the most powerful automation tools used for web scraping, browser automation, and testing. Often, there are cases where interacting with web elements using Selenium’s native methods may not be enough. This is where executing JavaScript in Python Selenium becomes crucial. JavaScript execution allows automation scripts to perform actions that are not directly supported by Selenium’s built-in methods.

In this article, we will explore how to execute JavaScript using Python Selenium WebDriver effectively. We will cover various use cases, such as scrolling the page, clicking hidden elements, extracting data, modifying elements, and handling AJAX requests.

How to Execute JavaScript in Selenium

Selenium provides a built-in method called execute_script() to run JavaScript commands. The syntax is as follows:

driver.execute_script("JavaScript_Code")

1. Scrolling the Web Page

Sometimes, elements are not visible until you scroll down. You can use JavaScript to scroll to a specific position or until an element is in view:

from selenium import webdriver

# Initialize the driver
driver = webdriver.Chrome()
driver.get(""https://automationbysqatools.blogspot.com/2021/05/dummy-website.html)

# Scroll down by 1000 pixels
driver.execute_script("window.scrollBy(0,1000);")

Alternatively, scroll to an element:

element = driver.find_element("id", "element_id")
driver.execute_script("arguments[0].scrollIntoView();", element)

2. Clicking Hidden Elements

Some elements are hidden due to overlays or display properties. Use JavaScript to forcefully click them:

element = driver.find_element("id", "hidden_button")
driver.execute_script("arguments[0].click();", element)

3. Extracting Data Using JavaScript

If an element’s text is dynamically generated via JavaScript, traditional Selenium methods might fail. Instead, execute JavaScript to retrieve the content:

text = driver.execute_script("return document.getElementById('element_id').innerText;")
print(text)

4. Modifying Web Elements

You can also use JavaScript to modify the DOM elements dynamically:

driver.execute_script("document.getElementById('element_id').value='New Value';")

5. Handling AJAX Requests

Sometimes, elements take time to load due to AJAX. You can use JavaScript to check when all AJAX calls are complete:

driver.execute_script("return jQuery.active == 0;")

Executing JavaScript with Return Values

JavaScript executed in Selenium can also return values, making it useful for retrieving attributes, inner text, and other information.

page_title = driver.execute_script("return document.title;")
print("Page Title:", page_title)

Getting Element Attributes

element = driver.find_element("id", "element_id")nattribute = driver.execute_script("return arguments[0].getAttribute('href');", element)
print(attribute)

Common Use Cases of JavaScript Execution in Selenium

1. Handling Disabled Elements

Some elements are disabled by default. Use JavaScript to enable and interact with them:

driver.execute_script("document.getElementById('submit_button').removeAttribute('disabled');")

2. Setting Cookies

To set cookies manually:

driver.execute_script("document.cookie = 'username=JohnDoe';")

3. Changing Element Style

Modify element styles dynamically:

driver.execute_script("document.getElementById('box').style.backgroundColor = 'red';")

Best Practices for Using JavaScript in Selenium

  1. Use JavaScript as a last resort – Always try Selenium’s native methods first.
  2. Ensure browser compatibility – Some JavaScript functions behave differently in various browsers.
  3. Handle exceptions properly – Wrap JavaScript execution in try-except blocks to catch errors.
  4. Use explicit waits – JavaScript execution doesn’t wait for elements to load, so use WebDriverWait when necessary.
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

wait = WebDriverWait(driver, 10)
element = wait.until(EC.presence_of_element_located((By.ID, "element_id")))
driver.execute_script("arguments[0].click();", element)

<< Previous
Next >>

How to Handle Dropdowns in Python Selenium

by

When automating web applications, handling dropdown menus is a crucial task. Selenium WebDriver, a powerful tool for web automation, provides multiple ways to interact with dropdowns efficiently. In this guide, we will explore various methods to handle dropdowns in Python Selenium with practical examples.

What is a Dropdown in Selenium?

A dropdown menu is an HTML element that allows users to select an option from a list. These elements are commonly created using the <select> tag. Selenium provides the Select class to interact with such dropdown elements easily.

Importing Required Libraries

Before handling dropdowns, ensure you have Selenium installed in your Python environment.

Now, import the necessary modules:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import Select

Handling Dropdowns Using Selenium

1. Selecting an Option by Visible Text

This is the most common way to select an item from a dropdown. The select_by_visible_text() method is used to select an option based on its displayed text.

import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.select import Select

# Initiate Webdriver
driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(10)

# Launch dummy website
driver.get("https://automationbysqatools.blogspot.com/2021/05/dummy-website.html")

# Select dropdown one element
drop_down_element = driver.find_element(By.ID, "admorepass")
select_obj = Select(drop_down_element)

# Select dropdown option with select_by_visible_text
select_obj.select_by_visible_text("Add 1 more passenger (100%)")

# Select country dropdown element
country_dd = driver.find_element(By.ID, "billing_country")
select_obj2 = Select(country_dd)
select_obj2.select_by_visible_text("India")
time.sleep(5)

# Close the Browser
driver.close()

2. Selecting an Option by Index

If you know the position of the option, you can select it using select_by_index().

dropdown.select_by_index(2)  # Selects the third option (Index starts at 0)
import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.select import Select

# Initiate Webdriver
driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(10)

# Launch dummy website
driver.get("https://automationbysqatools.blogspot.com/2021/05/dummy-website.html")

# Select add more passenger dropdown element
drop_down_element = driver.find_element(By.ID, "admorepass")
select_obj = Select(drop_down_element)

# Select value by select_by_index() method
select_obj.select_by_index(2)

# Select country dropdown element
country_dd = driver.find_element(By.ID, "billing_country")
select_obj2 = Select(country_dd)

# Select value by select_by_index() method
select_obj2.select_by_index(10)
time.sleep(5)

# Close the Browser
driver.close()

3. Selecting an Option by Value Attribute

Each dropdown option has a value attribute that can be used for selection.

dropdown.select_by_value("option2")  # Selects the option with value "option2"
import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.select import Select

# Initiate Webdriver
driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(10)

# Launch dummy website
driver.get("https://automationbysqatools.blogspot.com/2021/05/dummy-website.html")

# Select add more passenger dropdown element
drop_down_element = driver.find_element(By.ID, "admorepass")
select_obj = Select(drop_down_element)

# Select dropdown option by value option
select_obj.select_by_value("3")

# Select country dropdown element
country_dd = driver.find_element(By.ID, "billing_country")
select_obj2 = Select(country_dd)
select_obj2.select_by_value("BE") # Belarus country
time.sleep(10)

# Close the Browser
driver.close()

4. Getting All Dropdown Options

Sometimes, you may need to extract all options from a dropdown.

options = dropdown.options
for option in options:
    print(option.text)  # Prints all available options

5. Deselecting Options (For Multi-Select Dropdowns)

If the dropdown allows multiple selections, you can deselect options using:

dropdown.deselect_by_index(1)
dropdown.deselect_by_value("option2")
dropdown.deselect_by_visible_text("Option 3")
dropdown.deselect_all()  # Clears all selections

Handling Non-Select Dropdowns

Some dropdowns are not built using the <select> tag. Instead, they rely on div, span, or ul/li elements. In such cases, JavaScript execution or direct element interaction is required.

1. Clicking to Reveal Options and Selecting One

dropdown_button = driver.find_element(By.XPATH, "//div[@class='dropdown']")
dropdown_button.click()

option_to_select = driver.find_element(By.XPATH, "//li[text()='Option 1']")
option_to_select.click()

2. Using JavaScript to Select an Option

For complex dropdowns, JavaScript can be used:

script = "document.querySelector('css-selector-for-dropdown').value='option_value'"
driver.execute_script(script)

Best Practices for Handling Dropdowns in Selenium

  • Use explicit waits to ensure the dropdown loads before interaction.
  • Handle stale element exceptions if dropdown updates dynamically.
  • Use appropriate selection methods based on the dropdown structure.
  • Validate selections by retrieving the selected option.
<< Previous
Next >>

Handle Alerts in Python Selenium

by

Introduction to Handling Alerts in Python Selenium

Selenium is one of the most widely used frameworks for automating web browsers. It provides robust features to interact with web elements, navigate pages, and handle pop-ups efficiently. One of the critical aspects of web automation is handling alerts, which appear as pop-ups and require user interaction. In this comprehensive guide, we will explore the different types of alerts and how to handle them using Python Selenium.

Types of Alerts in Selenium

Alerts in Selenium can be broadly categorized into three types:

  1. Simple Alert – Displays a message with an OK button.
  2. Confirmation Alert – Displays a message with OK and Cancel buttons.
  3. Prompt Alert – Displays a message with an input field, allowing user input before clicking OK or Cancel.

Import Required Modules

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.alert import Alert
import time

Handling Simple Alerts in Selenium

A simple alert consists of a message and an OK button. Selenium provides the switch_to.alert method to interact with alerts.

Example Code:

import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.alert import Alert

# Initialize WebDriver
driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(10)

# Open a webpage with an alert
driver.get("https://automationbysqatools.blogspot.com/2020/08/alerts.html")

# Click button to launch alert
driver.find_element(By.ID, "btnShowMsg").click()
time.sleep(2)

# Create alert object
alert = Alert(driver)
print(alert.text)
time.sleep(2)

# Accept alert
alert.accept()

# Close browser
driver.quit()

Handling Confirmation Alerts in Selenium

A confirmation alert contains an OK and Cancel button, requiring user interaction.

Example Code:

import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.alert import Alert

# Initialize WebDriver
driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(10)

# Open a webpage with an alert
driver.get("https://automationbysqatools.blogspot.com/2020/08/alerts.html")

confirm_btn = driver.find_element(By.ID, "button")
confirm_btn.click()
time.sleep(2)

# Create alert object
alert = Alert(driver)
print(alert.text)
time.sleep(2)

# Accept the alert
alert.accept()
UI_msg = driver.find_element(By.ID, "demo").text
print(UI_msg)
assert UI_msg == "You pressed OK!"

confirm_btn = driver.find_element(By.ID, "button")
confirm_btn.click()
# Dismiss the alert
alert.dismiss()

UI_msg_cancel = driver.find_element(By.ID, "demo").text
print(UI_msg_cancel)
assert UI_msg_cancel == "You pressed Cancel!"

# Close Browser
driver.quit()

Handling Prompt Alerts in Selenium

A prompt alert allows the user to enter input before dismissing the alert.

Example Code:

import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.alert import Alert

# Initialize WebDriver
driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(10)

# Open a webpage with an alert
driver.get("https://automationbysqatools.blogspot.com/2020/08/alerts.html")

# Click button to launch prompt alert popup
prompt_box = driver.find_element(By.ID, "promptbtn")
prompt_box.click()
time.sleep(3)

# Create alert object
alert_prompt = Alert(driver)
new_value = "SQA"

# Send text to prompt box
alert_prompt.send_keys(new_value)
time.sleep(3)
# Accept the alert
alert_prompt.accept()

# Verify text on UI
ui_msg = driver.find_element(By.ID, "prompt")
expected_msg = f"Hello {new_value}! How are you today?"
assert ui_msg == expected_msg
time.sleep(5)


prompt_box = driver.find_element(By.ID, "promptbtn")
prompt_box.click()
time.sleep(3)

# Dismiss the prompt
alert_prompt.dismiss()
ui_msg = driver.find_element(By.ID, "prompt")
expected_msg = f"User cancelled the prompt."
assert ui_msg == expected_msg

# Close browser
driver.quit()

Best Practices for Handling Alerts in Selenium

  1. Use Explicit Waits: Instead of time.sleep(), use WebDriverWait to handle dynamic alerts.
  2. Validate Alert Text: Always verify the alert text before taking action.
  3. Handle NoAlertPresentException: Wrap alert handling in a try-except block to avoid exceptions if no alert appears.

Example Using WebDriverWait

import time
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.common.alert import Alert

# Initialize WebDriver
driver = webdriver.Chrome()

driver.get("https://automationbysqatools.blogspot.com/2020/08/alerts.html")

try:
    WebDriverWait(driver, 10).until(EC.alert_is_present())
    driver.find_element(By.ID, "btnShowMsg").click()
    time.sleep(2)
    alert = Alert()
    print("Alert found: ", alert.text)
    alert.accept()
except:
    print("No alert present")

# Close Browser
driver.quit()
<< Previous
Next >>

Right Click in Python Selenium

by

Selenium provides the ability to automate right-click (context-click) operations using its ActionChains class. Right-clicking is essential for testing functionalities like context menus, custom event handlers, and hidden options in web applications. This article provides a comprehensive guide on how to perform right-click ( (context-click) operations in Selenium using Python.

Setting Up Selenium for Context-Click

To perform a context-click action, we need to:

  1. Identify the target element (the element where we want to perform a right-click).
  2. Use ActionChains to execute the context-click operation.

Importing Required Libraries

from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
import time

Locating Elements for Context-Click

To successfully perform a context-click operation, we must locate the element properly. The most common ways to locate elements in Selenium include:

  • By ID: driver.find_element(By.ID, “context-menu”)
  • By Class Name: driver.find_element(By.CLASS_NAME, “context-item”)
  • By XPath: driver.find_element(By.XPATH, “//*[@id=’context-menu’]”)

Performing Context-Click in Selenium using ActionChains

The ActionChains class provides the context_click() method, which allows us to automate right-click interactions in web applications.

import time
# install pyautogui library using below command
# pip install pyautogui
import pyautogui
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains

# Initialize WebDriver
driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(15)

# Launch website on browserdriver.get("https://www.globalsqa.com/demo-site/draganddrop/")
about_element = driver.find_element(By.XPATH, "//div[@id='menu']//a[text()='About']")

action = ActionChains(driver)
# Perform context-click (right-click)
action.context_click(about_element).perform()

# Using pyautogui library to perform action context click
time.sleep(5)
pyautogui.press("up")
time.sleep(2)
pyautogui.press("enter")
time.sleep(5)

driver.quit()
<< Previous
Next >>

Drag and Drop in Python Selenium

by

Selenium is a powerful tool for automating web browsers, and it supports drag-and-drop operations through its ActionChains class. Automating drag and drop is crucial for testing web applications that rely on interactive elements such as sortable lists, sliders, and draggable objects. This article will provide an in-depth guide on how to perform drag-and-drop operations in Selenium using Python

Setting Up Selenium for Drag and Drop

To perform a drag-and-drop action, we need to:

  1. Identify the source element (the element we want to drag).
  2. Identify the target element (the element where we want to drop the source element).
  3. Use ActionChains to execute the drag-and-drop operation.

Importing Required Libraries

from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
import time

Locating Elements for Drag and Drop

To successfully perform a drag-and-drop operation, we must locate the elements properly. The most common ways to locate elements in Selenium include:

  • By ID: driver.find_element(By.ID, “source-id”)
  • By Class Name: driver.find_element(By.CLASS_NAME, “source-class”)
  • By XPath: driver.find_element(By.XPATH, “//*[@id=’source’]”)

Performing Drag and Drop in Selenium using ActionChains

The ActionChains class provides the drag_and_drop() method, which allows us to automate drag-and-drop interactions in web applications.

import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains

# Initialize WebDriver
driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(15)

driver.get("https://www.globalsqa.com/demo-site/draganddrop/")
# Switch to the iframe
iframe_element = driver.find_element(By.XPATH, "//iframe[@class='demo-frame lazyloaded']")
driver.switch_to.frame(iframe_element)

# Get source element
image_element = driver.find_element(By.XPATH, "//h5[text()='High Tatras']//parent::li")

# Get target element
trash_element = driver.find_element(By.ID, "trash")

# Create an ActionChains object
action = ActionChains(driver)

# Drag and drop image from one source to target element.
action.drag_and_drop(image_element, trash_element).perform()
time.sleep(5)

driver.quit()

Performing Drag and Drop Using Click and Hold Method

An alternative approach to executing drag and drop involves using click_and_hold(), move_to_element(), and release(). This method is useful when drag_and_drop() does not work due to JavaScript-based UI interactions.

import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains

# Initialize WebDriver
driver = webdriver.Chrome()
driver.maximize_window()
driver.implicitly_wait(15)

# Launch a URL on browser
driver.get("https://www.globalsqa.com/demo-site/draganddrop/")

# Switch to the iframe
iframe_element = driver.find_element(By.XPATH, "//iframe[@class='demo-frame lazyloaded']")
driver.switch_to.frame(iframe_element)

# Get source element
image_element = driver.find_element(By.XPATH, "//h5[text()='High Tatras']//parent::li")

# Get target element
trash_element = driver.find_element(By.ID, "trash")

# Create an ActionChains object
action = ActionChains(driver)

# Perform drag and drop using an alternative method
action.click_and_hold(image_element).move_to_element(trash_element).release()
action.perform()
time.sleep(5)

driver.quit()
<< Previous
Next >>

Mouse Hover Action In Selenium

by

Mastering Mouse Hover Action in Selenium with Python: A Comprehensive Guide

When delving into the realm of web automation, particularly with Selenium in Python, one often encounters scenarios where merely clicking elements is insufficient. There are instances where a more nuanced interaction—such as hovering over an element to trigger a dropdown or unveil hidden options—is indispensable. This is where Selenium’s ActionChains class becomes a pivotal asset.

Understanding the Significance of Mouse Hover Actions

Many modern web applications leverage hover effects to provide interactive user experiences. For instance, e-commerce websites frequently employ hover actions to reveal product details or additional purchase options. Automating such interactions necessitates simulating a user hovering their cursor over a designated web element, which can be effortlessly achieved using Selenium’s ActionChains.

Implementing Mouse Hover Using ActionChains

To execute a hover action, the ActionChains class provides the move_to_element() method, which simulates the cursor hovering over a specified element.

Step-by-Step Implementation

from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
import time

# Initialize WebDriver
driver = webdriver.Chrome()

# Open flipkart website
driver.get("https://www.flipkart.com/")  
driver.maximize_window()
driver.implicitly_wait(10)

# Locate the element to hover over
element_to_hover = driver.find_element(By.XPATH, "//div[@aria-label='Fashion']")

# Create an ActionChains object
actions = ActionChains(driver)

# Perform the hover action
actions.move_to_element(element_to_hover).perform()

# Pause to observe the effect
time.sleep(3)

# Closing the browser
driver.quit()

Exploring Advanced Hover Scenarios

  1. Hover and Click on a Revealed Element: In cases where an element becomes visible only after hovering, you can chain actions as follows:
    revealed_element = driver.find_element(By.XPATH, “//div[@aria-label=’Fashion’]”) actions.move_to_element(element_to_hover).click(revealed_element).perform()
  2. Hover Over Nested Elements: If you need to hover over multiple elements sequentially, chain multiple move_to_element() calls:
    submenu = driver.find_element(By.XPATH, “//div[@class=’submenu’]”) actions.move_to_element(element_to_hover).move_to_element(submenu).perform()
  3. Hover Using Offsets: Sometimes, elements may not have distinct locators, requiring precise control using coordinates:
<< Previous
Next >>