Get Text Selenium Method

by

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:

  1. Initialize the WebDriver: Start the WebDriver for the browser you want to use.
  2. Navigate to the webpage: Use driver.get() to open the page where the target element is located.
  3. 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.
  4. Retrieve the text: Use the text method on the element to get its visible text.
  5. 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.
<< Previous
Next >>

click Method

by

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://www.facebook.com")

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

# Close the browser
driver.quit()

Steps to use click():

  1. Initialize the WebDriver: Start by setting up the WebDriver for the browser you are automating (e.g., Chrome, Firefox).
  2. Navigate to the webpage: Use driver.get() to load the webpage.
  3. 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.
  4. 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.

<< Previous
Next >>

send_keys Method

by

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.
<< Previous
Next >>

Selenium Waits

by

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:

  1. Implicit Waits
  2. Explicit Waits
  3. 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()
<< Previous
Next >>



Dummy Booking Website

by

Dummy ticket websites provide different web elements to do the automation



Dummy Ticket Booking Website



Choose the correct option:

  • Dummy ticket for visa application – $200
  • Dummy return ticket – $300
  • Dummy hotel booking ticket – $400
  • Dummy hotel and flight booking – $500
  • Cab booking and return date – $600

Passenger Details


First Name

Last Name

Date of birth*

Sex*
Male Female




Number of Additional Passangers




Travel Details


One Way Round Trip



Delivery Option





How will you like to receive the dummy ticket(optional)

Email WhatsApp Both


Billing Details


























Most Visited Cities


Select Option City ID City Name Passengers
6001 Mumbai 1033
6002 Pune 2002
6003 Indore 3000
6004 Kolkata 5000
6005 Hyderabad 6000
6006 Orangabad 3456
6007 Delhi 5666









is_selected Method

by

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.

<< Previous
Next >>

is_displayed Method

by

The is_displayed() method in Selenium is used to check whether a web element is visible to the user on the webpage. This method returns True if the element is visible and False if it is hidden (e.g., using CSS display: none, visibility: hidden, or if it is outside the viewport).

Syntax:

element.is_displayed()

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 URL
driver.get('https://www.google.com')

# Locate the element (e.g., a button or div)
element = driver.find_element(By.NAME, 'q')

# Check if the element is displayed
if element.is_displayed():
    print("The element is visible on the page.")
else:
    print("The element is not visible on the page.")

# Close the browser
driver.quit()

Explanation:

  • element.is_displayed() returns True if the element is visible to the user.
  • This method can be useful when you want to verify if an element is present on the page and is currently visible (not hidden or collapsed).
<< Previous
Next >>

is_enabled Method

by

The is_enabled() method in Selenium is used to check whether a web element is enabled or not. This is typically used to verify if an input element, button, or other interactive elements are enabled for interaction (e.g. if they are clickable or can receive input).

Here’s a basic example of how to use is_enabled() in Python with Selenium:

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 of any website
driver.get('https://www.google.com')

# Locate the element (e.g., a button or input field)
element = driver.find_element(By.NAME, 'q')

# Check if the element is enabled ot not
if element.is_enabled():
    print("The element is enabled.")
else:
    print("The element is disabled.")

# Close the browser
driver.quit()

Explanation:

  • element.is_enabled() returns True if the element is enabled, and False if it is disabled.
  • You can use this method before interacting with elements like buttons or input fields to ensure that they are available for interaction.
<< Previous
Next >>

find_element and find_elements methods

by

In Selenium, two commonly used methods to locate elements on a web page are find_element and find_elements . They allow you to interact with HTML elements like buttons, links, text fields, etc. Let’s break them down

find_element Method

The find_element method is used to locate a single web element on the page. It returns the first matching element it finds. If it doesn’t find the element, it will raise a NoSuchElementException.

Syntax:

element = driver.find_element(by, value)
  • By : Locator strategy (e.g., By.ID, By.XPATH, By.Name, etc.).
  • value: The value that matches the element you want to find (e.g., the element’s ID, name, class, or other attributes).

Example:

If you want to find an element by its ID:

element = driver.find_element(By.ID, 'username')
element.send_keys('my_username')

Here, Selenium will locate the element with the ID username and send a text to it.

Common Locator Strategies for find_element:

  • By.ID : Finds an element by its ID attribute.
  • By.NAME: Finds an element by its name attribute.
  • By.CLASS_NAME: Locates elements by the class name.
  • By.XPATH: Locates elements using an XPath expression.
  • By.CSS_SELECTOR: Finds elements using a CSS selector.
  • By.TAG_NAME: Locates elements by their tag name (e.g., h1, input).

find_elements Method

The find_elements method is used to locate multiple elements on a web page. It returns a list of all matching elements. If no elements are found, it returns an empty list (instead of raising an exception).

Syntax:

elements = driver.find_elements(by, value)
  • Similar to find_element, but it returns a list of elements.

Example:

To find all elements with a specific class name:

elements = driver.find_elements(By.CLASS_NAME, 'product')
for element in elements:
    print(element.text)

In this case, all elements with the class name product will be located, and their text content will be printed.

Key Differences Between find_element and find_elements:

find_elementfind_elements
Returns one element (the first match)Returns a list of matching elements
Raises NoSuchElementException if no element is foundReturns an empty list if no elements are found
Best for situations where only one element is expectedIt is ideal when you want to find multiple elements (e.g., list items, products)
<< Previous
Next >>

Different Browsers Execution with Selenium

by

Selenium is an open-source tool that automates browsers. It’s widely used in web testing to simulate user interaction with a website across different browsers

Introduction to Selenium and Browser Automation

Selenium is an open-source tool that automates browsers. It’s widely used in web testing to simulate user interaction with a website across different browsers, ensuring that it functions correctly. From clicking buttons to filling out forms, Selenium makes it easy for developers and testers to automate these tasks using different browsers. This capability is vital for cross-browser compatibility testing to verify that a website works smoothly across various platforms.

With Python being one of the most popular programming languages, combining Selenium with Python provides a simple, yet powerful, solution for automating browsers. Let’s explore how you can execute Selenium scripts across different browsers using Python.

Popular Browsers Supported by Selenium

Selenium supports several browsers, ensuring you can automate tasks across multiple platforms. Here are some popular browsers supported:

  • Google Chrome: The most widely used browser, known for its speed and reliability.
  • Mozilla Firefox: Open-source, secure, and highly customizable.
  • Microsoft Edge: Built on Chromium, Microsoft’s modern browser.
  • Safari: Apple’s browser, mainly used on macOS and iOS.

Running Automation Scripts in Chrome Browser

Here’s an example of launching a website and interacting with it:

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

# Launch chrome browser 
driver = webdriver.Chrome()
driver.implicitly_wait(20)
driver.maximize_window()

# Open google page on the browser
driver.get('https://www.google.co.in')

# Send text to google search field
driver.find_element(By.NAME, 'q').send_keys('Selenium automation')

# Click on search button
driver.find_element(By.NAME, 'btnK').click()

# Close browser
driver.close()

Running Automation Scripts in Firefox Browser

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

# Launch Firefox browser
driver = webdriver.Firefox()
driver.implicitly_wait(20)
driver.maximize_window()

# Open google page on the browser
driver.get('https://www.google.co.in')

# Send text to google search field
driver.find_element(By.NAME, 'q').send_keys('Selenium automation')

# Click on search button
driver.find_element(By.NAME, 'btnK').click()

# Close browser
driver.close()

Running Automation Scripts in Edge Browser

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

# Launch Edge browser
driver = webdriver.Edge()
driver.implicitly_wait(20)
driver.maximize_window()

# Open google page on the browser
driver.get('https://www.google.co.in')

# Send text to google search field
driver.find_element(By.NAME, 'q').send_keys('Selenium automation')

# Click on search button
driver.find_element(By.NAME, 'btnK').click()

# Close browser
driver.close()

Combine Scripts to run with all Browser

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


browser_name = 'Chrome'
driver = None
"""
Launch different browser as per 
the value of browser_name variable
"""
if browser_name.lower() == 'chrome':
    driver = webdriver.Chrome()
elif browser_name.lower() == 'firefox':
    driver = webdriver.Firefox()
elif browser_name.lower() == 'Edge':
    driver = webdriver.Edge()

driver.implicitly_wait(20)
driver.maximize_window()

# Open google page on the browser
driver.get('https://www.google.co.in')

# Send text to google search field
driver.find_element(By.NAME, 'q').send_keys('Selenium automation')

# Click on search button
driver.find_element(By.NAME, 'btnK').click()

# Close browser
driver.close()
<< Previous
Next >>