Handle Browser Windows/Tabs

To handle browser tabs in Selenium using Python, you can use methods to switch between windows or tabs using their handles. Here’s a guide on how to open a new tab, switch between tabs, and close

Example Code

from selenium import webdriver
import time

# Initialize the WebDriver (e.g., using Chrome)
driver = webdriver.Chrome()
driver.implicitly_wait(10)

# Open the first URL
driver.get("https://www.facebook.com")
print("Current tab URL:", driver.current_url)

# Save the original window handle
original_tab = driver.current_window_handle

# Open a new tab using JavaScript (useful for browsers like Chrome)
driver.execute_script("window.open('https://www.google.com', '_blank');")

# Get the list of all window handles (tabs)
window_handles = driver.window_handles
print("All window handles:", window_handles)

# Switch to the new tab
driver.switch_to.window(window_handles[1])
print("Switched to new tab URL:", driver.current_url)

# Pause for a few seconds (optional)
time.sleep(2)
# close google page
driver.close()

# Switch back to the original tab
driver.switch_to.window(original_tab)
print("Switched back to original tab URL:", driver.current_url)

time.sleep(2)

# Close the browser
driver.quit()

Explanation:

driver.window_handles: Returns a list of window handles (IDs) for all the open tabs/windows.
driver.switch_to.window(handle): Switches the WebDriver’s focus to the specified window handle.
driver.execute_script("window.open('URL', '_blank');"): Opens a new tab using JavaScript.
To close a specific tab, you can use driver.close() while the focus is on that tab.

This approach allows you to manage multiple tabs efficiently, such as switching between them or closing specific ones as needed.

Take Screenshot Selenium

To take screenshot using Selenium in Python, you can use the save_screenshot() method or get_screenshot_as_file() method. Here’s how you can do it:

Example Code

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

# Initialize the WebDriver (e.g., using Chrome)
driver = webdriver.Chrome()

# Navigate to a website
driver.get("https://www.google.com")

# Take a screenshot and save it as a file
screenshot_path = "google_page.png"
driver.save_screenshot(screenshot_path)
# Or driver.get_screenshot_as_file(screenshot_path)

print(f"Screenshot saved at: {screenshot_path}")

search_field = driver.find_element(By.NAME, "q")

# Take a screenshot of the specific element
search_field.screenshot("search_field.png")

# Close the browser
driver.quit()

Explanation:

driver.save_screenshot("filename.png"): Saves a screenshot of the current browser window with the specified filename.
element.screenshot("filename.png"): Saves a screenshot of the specific element with the specified filename.
You can use any valid file path or name as the argument to save the screenshot where you want.

Forward, Back and Refresh Methods

In Selenium with Python, you can use the back(), forward(), and refresh() methods to navigate through browser history and reload pages. Here’s a quick overview of how to use them

Example Code

from selenium import webdriver
import time

# Initialize the WebDriver (e.g., using Chrome)
driver = webdriver.Chrome()

# Navigate to a URL
driver.get("https://www.google.com")
print("Initial URL:", driver.current_url)

# Navigate to another URL
driver.get("https://www.facebook.com")
print("Navigated to:", driver.current_url)

# Go back to the previous page
driver.back()
print("Back to:", driver.current_url)
# Back URL should be www.google.com

# Wait for 2 seconds
time.sleep(2)

# Move forward in the browser history
driver.forward()
print("Forward to:", driver.current_url)
# Move forward url to www.facebook.com

# Wait for 2 seconds
time.sleep(2)

# Refresh the current page ( facebook.com )
driver.refresh()
# Refresh facebook URL
print("Page refreshed at:", driver.current_url)

# Close the browser
driver.quit()

Results:

Initial URL: https://www.google.com/ Navigated to: https://www.facebook.com/ Back to: https://www.google.com/ Forward to: https://www.facebook.com/ Page refreshed at: https://www.facebook.com/

Explanation:

driver.back(): Navigates back to the previous page in the browser history.
driver.forward(): Moves forward in the browser history.
driver.refresh(): Refreshes/reloads the current page.

Get Current URL

To get the current URL in Python using Selenium, you can use the current_url property of the WebDriver instance. Here’s how you can do it:

from selenium import webdriver

# Example using Chrome WebDriver
driver = webdriver.Chrome()

# Navigate to a website
driver.get("https://sqatools.in/")

# Get the current URL
current_url = driver.current_url
print("Current URL:", current_url)

# Close the browser
driver.quit()

This will print the current URL of the page that the WebDriver is on.

In Selenium with Python, the get_attribute() method is used to retrieve the value of a specific attribute from an HTML element. This can be particularly useful when you need to access values like href for links, src for images, class, id, or other attributes of HTML elements.

Basic Syntax

element = driver.find_element(By.XPATH, 'your_xpath_here')
attribute_value = element.get_attribute('attribute_name')

Example Usage

Here’s an example of how you might use get_attribute() to get the URL from a link:

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

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

# Open a webpage
driver.get('https://sqatools.in/')

# Find an element and get its attribute
element = driver.find_element(By.XPATH, "//a[text()='Python Tutorials']")
href_value = element.get_attribute('href')

print("The link URL is:", href_value)

# Close the WebDriver
driver.quit()

In this example:

driver.find_element(By.XPATH, '//a[text()='Python Tutorials']') locates an element with the XPath specified.
element.get_attribute('href') retrieves the href the attribute value of the located <a> (anchor) element.

Common Use Cases

href for link URLs
src for image URLs
class for CSS class names
id for unique identifiers
data-* attributes for custom data

Get Text Selenium Method

In Selenium with Python, the text method retrieves the visible text from a web element. This is useful when you need to get the content of an element like a <div>, <span>, <p>, or any other HTML tag that contains text.

Example:

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

# Initialize the WebDriver (this example uses Chrome)
driver = webdriver.Chrome()

# Open a webpage
driver.get("https://sqatools.in/dummy-booking-website/")

# Locate the element containing the header of website
element = driver.find_element(By.TAG_NAME, "h1")

# Get the heading text from the element
text_content = element.text

# Print the text content
print(text_content)  # Dummy Ticket Booking Website

# Close the browser
driver.quit()

Steps:

Initialize the WebDriver: Start the WebDriver for the browser you want to use.
Navigate to the webpage: Use driver.get() to open the page where the target element is located.
Find the element: Use one of the find_element methods (e.g., find_element(By.ID, By.XPATH, By.CLASS_NAME)) to locate the element.
Retrieve the text: Use the text method on the element to get its visible text.
Display or use the text: The text attribute returns the text as a string, which you can print or use in your logic.

Example using XPath:

element =driver.find_element(By.XPATH,"//div[@class='example-class']")
text_content = element.text
print(text_content)

Important Notes:

The text method only retrieves visible text: If the text is hidden via CSS (display: none;, visibility: hidden;, etc.), Selenium will not retrieve it.
Whitespace handling: The text method preserves the text formatting as it appears in the browser, so you may get extra spaces or line breaks.

click Method

In Selenium with Python, the click() method is used to simulate a mouse click on a web element, like a button, link, or any other clickable element. Before using the click() method

Here’s a basic example of how to use click():

Example:

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

# Initialize WebDriver (this example uses Chrome)
driver = webdriver.Chrome()

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

# Locate the element and click it (by ID)
element = driver.find_element(By.ID, "submit-button")
element.click()

# Close the browser
driver.quit()

Steps to use `click()`:

Initialize the WebDriver: Start by setting up the WebDriver for the browser you are automating (e.g., Chrome, Firefox).
Navigate to the webpage: Use driver.get() to load the webpage.
Find the element: Use one of the find_element methods (e.g., find_element(By.ID, By.XPATH, By.NAME)) to locate the web element.
Perform the click action: Call the click() method on the located element.

Common Locators:

By.ID: Locate by element’s ID.
By.XPATH: Locate using XPath.
By.NAME: Locate by element’s name attribute.
By.CLASS_NAME: Locate by element’s class name.
By.TAG_NAME: Locate by element’s tag name.

Example with XPath:

element = driver.find_element(By.XPATH, "//button[@class='submit']")
element.click()

Ensure that the element you are trying to click is visible and interactable. Sometimes, you may need to wait for the element to load, which can be done using Selenium’s WebDriverWait:

Using WebDriverWait:

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

# Wait for the element to be clickable
element = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.ID, "submit-button"))
)

element.click()

This example waits up to 10 seconds for the element to be clickable before performing the click action.

send_keys Method

The send_keys() method in Selenium is used to simulate typing text into input fields or elements such as text boxes, text areas, or other editable elements in web pages. It can also be used to send special keys like Enter, Tab, or Arrow keys by using the Keys class from selenium.webdriver.common.keys.

Syntax:

element.send_keys("text to input")

Example 1: Sending text to an input field

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

driver = webdriver.Chrome()
driver.get('https://www.google.co.in')

# Locate the input field
input_element = driver.find_element(By.NAME, 'q')

# Send text to the input field
input_element.send_keys("Python Selenium")

# Close the browser
driver.quit()

Example 2: Using special keys (e.g., Enter key)

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()
driver.get('https://www.google.co.in')

# Locate the input field
input_element = driver.find_element(By.NAME, 'q')

# Send text and press Enter
input_element.send_keys("search query", Keys.ENTER)

# Close the browser
driver.quit()

Common Use Cases:

Filling forms by sending text to multiple input fields.
Simulating keyboard actions such as pressing Enter, Tab, or navigating using arrow keys.

Selenium Waits

Selenium is an incredibly useful tool for automating web testing, but dealing with web elements that load dynamically can sometimes be tricky. This is where Selenium waits come into play.

Understanding Selenium Waits

Selenium waits allow you to manage timing issues and ensure that your script interacts with elements only when they’re ready. In this article, we’ll explore the different types of waits in Selenium, how to use them, and why they are essential in building robust automated tests.

Why Do We Need Waits in Selenium?

One of the biggest challenges in web automation is dealing with dynamic content that loads at different speeds. If your script tries to interact with an element that hasn’t loaded yet, it can throw an error. To solve this, Selenium provides different types of waits to pause your script and give the page time to load before continuing.

Types of Selenium Waits

Selenium offers three primary types of waits to deal with dynamic web elements:

Implicit Waits
Explicit Waits
Fluent Waits

Let’s break down how each of these waits works.

1. Implicit Waits Explained

An Implicit Wait tells Selenium to wait for a specific amount of time before throwing an exception if an element isn’t found. This is like setting a blanket timeout for all the elements in your script.

How Implicit Waits Work

When you set an implicit wait, Selenium will pause the script for the given time, say 10 seconds, until the desired element becomes available. If it finds the element within that time, it proceeds. If not, it throws an exception

2. Explicit Waits Explained

Unlike implicit waits, Explicit Waits let you specify certain conditions under which Selenium should wait. Instead of just waiting for an element, it waits for a specific condition, like “element to be clickable” or “element to be visible.”

How Explicit Waits Work

You can define a condition in your script, and Selenium will keep checking for that condition to be met before interacting with the element. You can set both the condition and the maximum wait time.

3. Fluent Waits Explained

Fluent Waits offer more control by allowing you to set a polling interval, which determines how frequently Selenium checks if the condition is met. This wait is a more advanced form of explicit wait.

How Fluent Waits Differ from Explicit Waits

While both are condition-based waits, Fluent Waits let you customize the wait by defining the frequency with which Selenium checks the condition. Fluent waits are useful when you expect a delay but don’t want Selenium to keep waiting unnecessarily.

Using Polling Intervals with Fluent Waits

Fluent waits allow you to set a polling interval, like checking every 500 milliseconds, and can also ignore specific exceptions while waiting, which adds an extra layer of control to your tests.

Code Examples for Selenium Waits

Here are some practical examples of how to use different waits in Selenium with Python.

Using Implicit Waits in Python

from selenium import webdriver
driver = webdriver.Chrome()
driver.implicitly_wait(10)  # Set an implicit wait of 10 seconds
driver.get("https://sqatools.in/dummy-booking-website/")

Using Explicit Waits in Python

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

driver = webdriver.Chrome()
# Lauch chrome browser and open dummy website
driver.get("https://sqatools.in/dummy-booking-website/")

# Wait up to 10 seconds for the element to be clickable
element = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.ID, "firstname"))
)
element.click()
driver.close()

Using Fluent Waits in Python

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.support.ui import FluentWait
import time

driver = webdriver.Chrome()
driver.get("https://sqatools.in/dummy-booking-website/")

# Fluent wait example with a polling interval of 500 milliseconds
wait = WebDriverWait(driver, 10, poll_frequency=0.5, ignored_exceptions=[Exception])

# Wait for an element to be clickable
element = wait.until(EC.element_to_be_clickable((By.ID, "element_id")))
element.click()
driver.close()

is_selected Method

The is_selected() method in Selenium is used to check whether a web element, such as a checkbox, radio button, or option in a dropdown, is currently selected or not. It returns True if the element is selected and False if it is not.

Syntax:

element.is_selected()

Example:

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

# Set up the driver (assuming you're using Chrome)
driver = webdriver.Chrome()

# Open a webpage with website example
driver.get('https://example.com')

# Locate a checkbox or radio button element
checkbox = driver.find_element(By.ID, 'checkbox_id')

# Check if the checkbox is selected
if checkbox.is_selected():
    print("The checkbox is selected.")
else:
    print("The checkbox is not selected.")

# Close the browser
driver.quit()

Example with checkbox selection

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

driver = webdriver.Chrome()

driver.implicitly_wait(20)
driver.maximize_window()

# Open dummy website on the browser
driver.get('https://sqatools.in/dummy-booking-website/')

# get check element
checkbox_element = driver.find_element(By.XPATH, "//table//tr[2]//input")

# check is_selected status before selecting checkbox
print("is_selected status:", checkbox_element.is_selected()) # False

checkbox_element.click()

# check is_selected status after selecting checkbox
print("is_selected status:", checkbox_element.is_selected() # True

# Close browser
driver.quit()

Explanation:

element.is_selected() works primarily for form elements like checkboxes, radio buttons, and options within a <select> dropdown.
If the element is selected (checked for a checkbox, selected for a radio button or dropdown option), it returns True. Otherwise, it returns False.

This method is useful when you need to verify the state of form elements before taking further action.

Example Code

Explanation:

Example Code

Explanation:

Example Code

Explanation:

Basic Syntax

Example Usage

Common Use Cases

Example:

Steps:

Example using XPath:

Important Notes:

Example:

Steps to use click():

Common Locators:

Example with XPath:

Using WebDriverWait:

Syntax:

Example 1: Sending text to an input field

Example 2: Using special keys (e.g., Enter key)

Common Use Cases:

Understanding Selenium Waits

Syntax:

Example:

Example with checkbox selection

Explanation:

Steps to use `click()`: