• Selenium Features
• Selenium Installation
• Selenium Locators
• XPath Fundamentals
• CSS Selectors Methods
• Different Browsers Execution
• find_element & find_elements
• Check Enabled Status
• Check Displayed Status
• Check Selected Status
• Selenium Waits
• Send_keys Method
• Click Method
• Get Text
• Get Attribute Value
• Get Current URL
• Forward, Back, Refresh
• Take Screenshot
• Handle Browser Tabs
• Handle iframe
• Mouse Hover
• Context-Click
• Drag & Drop
• Handle Alerts
• Handle Dropdown
• Execute Javascript
• Scroll To element
• Headless Mode Execution
• Chrome Options
• Keyboard Action

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()

• Selenium Features
• Selenium Installation
• Selenium Locators
• XPath Fundamentals
• CSS Selectors Methods
• Different Browsers Execution
• find_element & find_elements
• Check Enabled Status
• Check Displayed Status
• Check Selected Status
• Selenium Waits
• Send_keys Method
• Click Method
• Get Text
• Get Attribute Value
• Get Current URL
• Forward, Back, Refresh
• Take Screenshot
• Handle Browser Tabs
• Handle iframe
• Mouse Hover
• Context-Click
• Drag & Drop
• Handle Alerts
• Handle Dropdown
• Execute Javascript
• Scroll To element
• Headless Mode Execution
• Chrome Options
• Keyboard Action

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()

• Selenium Features
• Selenium Installation
• Selenium Locators
• XPath Fundamentals
• CSS Selectors Methods
• Different Browsers Execution
• find_element & find_elements
• Check Enabled Status
• Check Displayed Status
• Check Selected Status
• Selenium Waits
• Send_keys Method
• Click Method
• Get Text
• Get Attribute Value
• Get Current URL
• Forward, Back, Refresh
• Take Screenshot
• Handle Browser Tabs
• Handle iframe
• Mouse Hover
• Context-Click
• Drag & Drop
• Handle Alerts
• Handle Dropdown
• Execute Javascript
• Scroll To element
• Headless Mode Execution
• Chrome Options
• Keyboard Action

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.