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

CSS Selectors in Selenium

by

CSS (Cascading Style Sheets) Selectors are patterns used to select the content you want to style. In Selenium, CSS Selectors find HTML elements based on their CSS properties

CSS Selector in Selenium and Its Methods

Selenium is a powerful tool widely used to automate web applications for testing purposes. However, within Selenium, one of the key elements that make your automation effective is the ability to locate web elements accurately. Enter CSS Selectors – an efficient, flexible, and reliable way to identify elements in Selenium WebDriver. In this article, we’ll dive deep into CSS Selectors and their methods in Selenium.

Introduction to CSS Selectors

CSS (Cascading Style Sheets) Selectors are patterns used to select the content you want to style. In Selenium, CSS Selectors find HTML elements based on their CSS properties.

Why Use CSS Selectors in Selenium?

CSS Selectors offer several advantages: speed, simplicity, and compatibility. They allow you to quickly and effectively identify web elements, even those deeply nested within HTML code. This makes them ideal for locating complex elements that other strategies, like XPath, may struggle with.

CSS Selector vs. XPath: Which is Better?

Both CSS Selectors and XPath are popular choices in Selenium, but which is better? XPath is often considered more powerful due to its ability to navigate through both forward and backward elements. However, CSS Selectors are faster, and for front-end web developers, they are more familiar. CSS Selectors also work more seamlessly across different browsers.

Types of CSS Selectors in Selenium

CSS Selectors come in various forms, each suited for different use cases.

Basic CSS Selectors

  • ID Selector
    The ID selector selects an element based on its unique ID attribute. For example: #username.
  • Class Selector
    The class selector targets elements with a specific class attribute, written as: .login-button.
  • Tag Selector
    The tag selector selects all elements of a particular type (e.g., div, h1). For example: div.

Advanced CSS Selectors

  • Attribute Selector
    This selector selects elements based on an attribute and its value, like [type=’text’].

    Examples:
    input[id=’password’]
    input[name=’username’]
    span[data-testid=’facebook’]

  • Substring Matches
    With substring selectors, you can target elements based on part of their attribute value. For example, a[href^='https'] matches all links that start with “https”.

    Examples:
    input[data-ui-name^=”input_text”]
    label[for^=”search_type_option”]
    button[data-ui-name^=”input_location_to”]

Methods to Use CSS Selectors in Selenium

Selenium provides methods to use CSS Selectors to interact with elements.

Finding Elements with findElement and findElements

  • findElement:
    This method returns a single WebElement that matches the CSS Selector.
  • findElements:
    Unlike findElement, this returns a list of all matching WebElements.

Differences Between findElement and findElements

findElement will throw an exception if no elements are found, whereas findElements returns an empty list in such cases, making it a safer option for handling multiple matches.

Writing Efficient CSS Selectors

Creating efficient CSS Selectors is essential to improving test speed and reliability.

Best Practices for Writing CSS Selectors

  1. Keep it Simple: Avoid overcomplicating your selectors with too many attributes.
  2. Use IDs and Classes: These are faster and more reliable.
  3. Avoid Directly Using Styles: Use functional attributes rather than style-related ones for better maintainability.

CSS Selector Examples in Selenium

Using ID and Class Selectors

Example for ID Selector:

driver.find_element(By.CSS_SELECTOR, "#username").send_keys("user123");

Example for Class Selector:

driver.find_element(By.CSS_SELECTOR, ".login-button").click();

Example for Attribute Selector:

driver.find_element(By.CSS_SELECTOR,"input[type='password']").send_keys("mypassword");

Example for Substring Selector:

driver.find_element(By.CSS_SELECTOR,"a[href^='https']").click();
<< Previous
Next >>