Python Selenium

python-selenium

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.

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

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.

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)

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

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

XPath Fundamentals

by

XPath (XML Path Language) is a powerful query language used to select nodes from an XML or HTML document. In the context of Selenium, XPath is primarily used to locate elements in a web page. It provides a flexible way to navigate through elements and attributes in a document, even when no other locators like id, class, or name are available or unique

XPath Fundamentals

1. XPath Expression

  • An XPath expression is a string of characters used to navigate through the document’s structure (XML/HTML).
  • It works by selecting nodes in the document that match the given pattern.

2. Absolute XPath

  • Definition: An absolute XPath starts from the root node (i.e., the top of the HTML document) and specifies the exact path to reach the target element.
  • Syntax: Starts with a single slash / and navigates through each element in the hierarchy.
  • Example: /html/body/div[1]/div[2]/input
  • Pros: Simple to understand and write.
  • Cons: Very brittle— if the structure of the page changes, the XPath breaks easily.

3. Relative XPath

  • 1Definition: A relative XPath starts from anywhere in the HTML DOM structure and is much more flexible than an absolute XPath.
  • Syntax: Starts with a double slash // to indicate searching from anywhere in the document.
Example:   //input[@id='username']

In the above example, input is the tag name and id is an attribute of the web element.

  • Pros: Flexible and more resilient to page structure changes.
  • Cons: It can be slower if the XPath is too broad or inefficient.

Common XPath Methods and Functions

1. Basic Syntax:

  • //: Selects nodes in the document from the current node that match the selection, regardless of location.
  • /: Selects nodes relative to the immediate current node.

2. Selecting by Attribute :

  • Basic syntax : //tagname[@attribute=’attribute value’]
  • Select elements based on their attributes using the @ symbol.
  • Example: //input[@type='text']
  • Finds an <input> element where the type attribute equals "text".

Here are a few XPath examples from the Facebook login page.

  • //button[@data-testid=”royal-login-button”]
  • //div[@id=’reg_pages_msg’]
  • //a[@data-testid=’open-registration-form-button’]

3. Selecting by Text Content Using text() Method:

  • Basic syntax to write XPath with text method:
    //tagname[text()=’text value’]
  • Use text() to find an element based on its inner text.
    Example:
  • HTML code : <button class=’cotent’>Login </button>
  • Selects a <button> element that contains the text "Login".

4. Partial Match Using contains() Method.

  • XPath with attribute : //tagname[contains(@attribute=’attribute value’)]
  • XPath with text : //tagname[contains(text()=’text value’)]
  • contains() is used when only a partial value of the attribute or text is on UI.
  • Example 1: Contains in Attribute : //input[contains(@name, ‘user’)]
  • Finds an <input> element where the name of the attribute contains the word "user".
  • Example 2: Contains in Text: //button[contains(text(), 'submit')]
  • Finds a <button> the element where the visible text contains the word “Submit”.

5. XPath Using And / or

  • Combine multiple attributes to use and or or in XPath.
  • Example 1 : //input[@type='text' and @name='username']
    Finds an <input> element where type is "text" and name is "username".
  • Example 2 : //input[@type='text' or @name='username']
    Finds an <input> element where type is "text" and name is "username".

6. Selecting by Index

  • XPath allows selecting specific instances of elements in a list using square brackets [index].
  • Example: (//input[@type='text'])[1]
  • Selects the first <input> element of type "text".
  • Another example: //div[@class='example-class'][2]
  • Selects the second <div> element with class "example-class".

7. Parent-Child Relationship

  • Parent to Child: //div[@id='parent']/input
  • Selects the <input> element that is a direct child of a <div> element with id="parent".
  • XPath supports navigating parent-child and ancestor-descendant relationships
  • Descendant (grandchildren and below): //div[@id='parent']//input
  • Selects any <input> element that is a descendant (child, grandchild, etc.) of the <div> with id="parent".

8. Selecting Parent or Ancestor Nodes

  • Parent: //input[@id='child']/parent::div
  • Selects the parent <div> of the <input> element with id="child".

  • Ancestor: //input[@id='child']/ancestor::form
  • Selects the ancestor <form> element of the <input> with id="child".

9. XPath Axes

  • Axes refer to the relationship between nodes. These are useful for navigating around the document.

Some common axes:

  • following: Select all nodes after the current node.
    //input[@id='username']/following::input[1]
  • Selects the first <input> element after the <input> with id="username".

  • preceding: Select all nodes before the current node.
    //input[@id='username']/preceding::div[1]
  • Selects the first <div> element before the <input> with id="username".

  • following-sibling: Selects sibling nodes that come after the current node.
    //input[@id='username']/following-sibling::input

  • Selects the sibling <input> the element that follows the <input> with id="username".


  • preceding-sibling: Select sibling nodes that come before the current node
    //input[@id='password']/preceding-sibling::input

  • Selects the sibling <input> element that precedes the <input> with id="password".

XPath Examples in Selenium:

1. Selecting an element by ID using XPath

element = driver.find_element(By.XPATH, "//input[@id='username']")

2. Selecting an element by class name

element = driver.find_element(By.XPATH, "//div[@class='container']")

3. Selecting an element by text

element = driver.find_element(By.XPATH, "//button[text()='Submit']")

4. Using contains() in XPath

element = driver.find_element(By.XPATH, "//a[contains(text(), 'Login')]")

5. Selecting a parent element using XPath

element = driver.find_element(By.XPATH, "//span[@id='child']/parent::div")

Advanced XPath Concepts

1. Combining Multiple XPath Expressions

  • Sometimes, you may need to combine different XPath conditions to locate elements effectively. This can be achieved using logical operators like and and or.

  • Using and: Combines two conditions, and both must be true.
    //input[@type='text' and @name='username']
  • This expression selects an <input> element where type is "text" and name is "username".

  • Using or: Combines two conditions, where at least one must be true.
    //input[@type='text' or @type='password']
  • This selects all <input> elements where the type is either "text" or "password".

2. Working with Dynamic Elements

  • In many web applications, elements may have dynamically generated attributes (e.g., auto-generated id or class values that change with each page load). You can use partial matches with the contains() function to locate dynamic elements in such cases.

  • Example with dynamic id: //button[contains(@id, 'submit-')]

  • This selects a <button> element where the id contains "submit-", useful when the full id changes dynamically.


  • Handling Dynamic Classes: //div[contains(@class, 'active-item')]

  • Selects any <div> element that contains the class "active-item", even if the class attribute has multiple class names.

3. Handling Complex HTML Structures

  • Web pages often have deeply nested HTML structures, and finding elements buried several layers deep can be challenging. XPath can be used effectively to navigate through these structures.


  • Example with complex hierarchy : //div[@class='container']//ul/li/a

  • This selects any <a> the element that is inside an <li> element, which is part of a <ul> that is a descendant of a <div> with class "container".

  • The // allows searching for elements within all descendants of the specified node, not just direct children.

  • Using position(): XPath also allows you to select elements based on their position in the document. (//div[@class='container']//ul/li)[2]

  • This selects the second <li> element within the <ul> inside a <div> with class "container".

4. Working with Attributes that Don’t Have Values

  • Sometimes, elements may have attributes without values, or you may need to select elements based on the presence of an attribute, regardless of its value.

  • Example: //input[@disabled]

  • This selects all <input> elements that have the disabled attribute, regardless of its value.

5. Navigating Between Sibling Elements

  • XPath supports navigating between sibling elements, which can be useful when dealing with repetitive structures, such as lists or tables.

  • Select the next sibling element:
    //div[@class='current']/following-sibling::div[1]

  • This selects the first <div> element that is a sibling of the <div> with class "current" and comes immediately after it.


  • Select the previous sibling element:
    //div[@class='current']/preceding-sibling::div[1]

  • This selects the first <div> element that is a sibling of the <div> with class "current" and comes immediately before it.

XPath Best Practices

1. Use Relative XPath over Absolute XPath

  • While absolute XPath can pinpoint an element based on the full path from the root node, it is highly prone to breaking when the structure of the page changes. Relative XPath, on the other hand, starts searching from anywhere in the document and is more resilient to changes.

  • Avoid: /html/body/div[2]/div[1]/form/input

  • This will likely break if there’s even a slight change in the layout.

  • Preferred: //form[@id='loginForm']//input[@name='username']

2. Optimize XPath for Performance

  • XPath can sometimes be slow, especially on large or complex web pages. Using efficient XPath expressions can improve performance.

  • Use Direct Conditions: //div[@class='container']//*[text()='Submit']

  • Instead of searching broadly with multiple conditions, try to narrow down your search by providing direct attributes or shorter paths.

  • Avoid Over-Using //: The // operator searches through all descendants and can be slower. Use it only when necessary and prefer a more specific hierarchy if possible.






Selenium Locators

by

In Python Selenium, locators are used to find and interact with elements on a web page. These locators help Selenium identify web elements like buttons, text fields, links, etc., allowing you to perform actions like clicking, entering text, or extracting information.

Selenium offers several types of locators, each with its specific use case depending on how the element is defined in the HTML. Below are the most common Selenium locators and how to use each.

1. ID Locator

  • Syntax: driver.find_element(By.ID, “element_id”)
  • Use: When the HTML element has a unique id attribute.
  • Example:
    element = driver.find_element(By.ID, “username”)
    element.send_keys(“user123”)
  • Best Use Case: When an element has a unique ID, it is often the most reliable and fastest locator to use.

2. Name Locator

  • Syntax: driver.find_element(By.NAME, “element_name”)
  • Use: For locating elements use the name attribute in HTML.
  • Example:
    element = driver.find_element(By.NAME, “email”)
    element.send_keys(“example@example.com”)
  • Best Use Case: Useful when form elements (like input fields) have unique name attributes.

3. Class Name Locator

  • Syntax: driver.find_element(By.CLASS_NAME, “class_name”)
  • Use: To find an element based on the class attribute in the HTML.
  • Example:
    element = driver.find_element(By.CLASS_NAME, “submit-button”) element.click()
  • Best Use Case: When you want to locate elements that share the same class, like groups of buttons or text fields. However, it may not be ideal if multiple elements share the same class name.

4. Tag Name Locator

  • Syntax: driver.find_element(By.TAG_NAME, “tag_name”)
  • Use: For selecting elements by their HTML tag (like div, a, button, etc.).
  • Example:
    element = driver.find_element(By.TAG_NAME, “button”) element.click()
  • Best Use Case: Primarily used when you want to retrieve elements of a specific tag, e.g., collecting all a (link) tags on a page.

5. Link Text Locator

  • Syntax: driver.find_element(By.LINK_TEXT, “link_text”)
  • Use: Finds a link (anchor tag) by its exact text.
  • Example:
    element = driver.find_element(By.LINK_TEXT, “Click here”) element.click()
  • Best Use Case: When you’re searching for a hyperlink and you know the exact visible text of the link. This only works for a (anchor) tags.

6. Partial Link Text Locator

  • Syntax:
    driver.find_element(By.PARTIAL_LINK_TEXT, “partial_link_text”)
  • Use: Locates a link by matching a portion of the text contained within it.
  • Example:
    element = driver.find_element(By.PARTIAL_LINK_TEXT, “Click”) element.click()
  • Best Use Case: When the full link text is long or dynamic, and you want to match just a part of it. Like in cases where only part of the link text is known.

7. CSS Selector Locator

  • Syntax:
    driver.find_element(By.CSS_SELECTOR, “css_selector”)
  • Use: Uses CSS selectors to locate elements. CSS selectors are very powerful and can locate elements by their ID, class, attributes, or structure within the HTML.
  • Example:
    element = driver.find_element(By.CSS_SELECTOR, “input[type=’text’]”)
    element.send_keys(“sample text”)
  • Best Use Case: CSS selectors are highly versatile and can be used for complex locators. They are generally faster than XPath and allow targeting more specific elements.

Some common CSS selector examples:

  • By class: "input.submit"
  • By ID: "#submit-button"
  • By attribute: "input[name='username']"

8. XPath Locator

  • Syntax: driver.find_element(By.XPATH, “xpath_expression”)
  • Use: XPath allows you to locate elements via their hierarchical position in the HTML DOM. It’s very powerful but also the most complex locator type.
  • Example:
    element = driver.find_element(By.XPATH, “//input[@id=’username’]”) element.send_keys(“user123”)
  • Best Use Case: Useful for locating elements when no other locator (ID, name, class, etc.) is unique enough. XPath can navigate through parent, child, and sibling elements.

Some XPath examples:

  • By attribute: “//input[@id=’username’]”
  • By position: “//div[1]/input[2]”
  • Text-based: “//a[text()=’Login’]”

9. Custom Attribute Locators (with CSS or XPath)

  • CSS Example:
    driver.find_element(By.CSS_SELECTOR, “[attribute=’value’]”)
  • XPath Example:
    driver.find_element(By.XPATH, “//*[@attribute=’value’]”)
  • Use: For elements that have custom attributes in the HTML.
  • Example:
    element = driver.find_element(By.CSS_SELECTOR, “button[data-test=’submit’]”) element.click()
  • Best Use Case: Useful when elements have custom data attributes, e.g., data-* attributes.

Summary of Locator Use Cases:

  • ID: Fast and reliable if the element has a unique id.
  • Name: Ideal for form elements with unique name attributes.
  • Class Name: Great when classes are unique or used on a small number of elements.
  • Tag Name: Useful for locating elements by their tag type.
  • Link Text/Partial Link Text: Best for finding anchor elements with specific text.
  • CSS Selector: Versatile and often the fastest way to locate complex elements.
  • XPath: Powerful for locating elements that are deeply nested or don’t have unique attributes.
<< Previous
Next >>

Selenium Installation

by

Selenium installation is the first step to learning automation

1. Python Installation

  • Ensure you have Python installed on your system. You can download it from the official Python website.

  • Verify the installation by running the following command in your terminal or command prompt.
    python –version
  • If it returns the version number, Python is installed.

2. Install Selenium

  • Open a terminal or command prompt and use the following pip command to install Selenium.

    pip install selenium

3. Run the First Selenium Script

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

# Launch a browser
driver = webdriver.Chrome()

# maximize browser window
driver.maximize_window()

#  set implicit wait for 20 sec.
driver.implicitly_wait(20)

# open a facebook URL in the browser
driver.get("https://www.facebook.com")

# send username to field
driver.find_element(By.NAME, "email").send_keys("TestAdmin")

# send password to passwordfield
driver.find_element(By.NAME, "pass").send_keys("Admin@12345")

# click on login button
driver.find_element(By.NAME, "login").click()

# close current browser
driver.close()

Execute script with Firefox

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

# Launch a Firefox browser
driver = webdriver.Chrome()

# maximize browser window
driver.maximize_window()

#  set implicit wait for 20 sec.
driver.implicitly_wait(20)

# open a facebook URL in the browser
driver.get("https://www.facebook.com")

# send username to email field
driver.find_element(By.NAME, "email").send_keys("TestAdmin")

# send password to password field
driver.find_element(By.NAME, "pass").send_keys("Admin@12345")

# click on to login button
driver.find_element(By.NAME, "login").click()

# close current browser
driver.close()

<< Previous
Next >>

Python Selenium Tutorials

by

Python selenium tutorials contain all the topics related to selenium and methods belonging to browser action to automate any website.

Selenium is an open-source automation tool primarily used for automating web browsers. It allows developers and testers to simulate user interactions with web applications, making it highly valuable for testing and automating tasks on websites. Selenium supports multiple programming languages, platforms, and browsers.

Key Features and Functionality of Selenium:

1. Cross-Browser Testing:

Selenium supports multiple browsers like:

  • Google Chrome
  • Mozilla Firefox
  • Safari
  • Microsoft Edge
  • Internet Explorer

This allows automation scripts to be executed across different browser environments, ensuring consistent functionality across platforms.

2. Multi-Language Support:

Selenium supports various programming languages, making it flexible for different development environments:

  • Java
  • Python
  • C#
  • Ruby
  • JavaScript (Node.js)
  • PHP

Users can write test scripts in their preferred language.

3. Support for Different Operating Systems:

Selenium can be used on multiple operating systems:

  • Windows
  • macOS
  • Linux

This provides great flexibility to the tester to run tests on different platforms.

4. WebDriver:

Selenium WebDriver is the core component of the Selenium suite. It provides a programming interface to interact with web elements and simulate user actions like clicking, typing, navigating, etc. It interacts directly with the browser without requiring a middle-man, which ensures faster execution and more accurate testing.

5. Multiple Browser Tabs and Windows Support:

Selenium WebDriver can handle switching between multiple browser windows or tabs, helping in simulating real-world test cases like working with pop-ups, new windows, or new tabs.

6. Locating Web Elements:

Selenium offers various ways to locate web elements on a page using locators such as:

  • ID
  • Name
  • Class Name
  • XPath
  • CSS Selectors
  • Tag Name
  • Link Text These locators are used to interact with specific elements like buttons, text boxes, and links.

7. Headless Browser Testing:

Selenium supports headless testing, allowing tests to be run in the background without opening a visible browser. This can improve execution speed, especially when running tests on servers.

8. Selenium Grid:

Selenium Grid allows parallel execution of tests across different machines and browsers. It helps in reducing test execution time by distributing tests across multiple nodes.

9. Automation of Dynamic Web Applications:

Selenium can handle dynamic web pages where elements may change without refreshing the page. This is crucial for testing modern web applications that use technologies like AJAX.

10. Integration with Test Frameworks:

Selenium can be integrated with various test frameworks like:

  • TestNG (Java)
  • JUnit (Java)
  • PyTest (Python)
  • NUnit (C#)

These integrations provide powerful features for assertion, test reporting, and grouping test cases.

11. Handling Alerts and Frames:

Selenium provides functionality to handle browser alerts (pop-ups), and work with iFrames (inline frames) within web pages. This is essential for testing interactions with these web elements.

12. Custom Waits:

Selenium offers both implicit and explicit waits, ensuring the web elements are properly loaded before interacting with them. This helps in making the tests more stable and robust, especially when dealing with slow-loading elements.

13. Data-Driven Testing:

Selenium can be integrated with external data sources like Excel, CSV, or databases, allowing testers to implement data-driven testing. This allows the same test script to run with multiple sets of data, improving test coverage.

14. Record and Playback (Selenium IDE):

Selenium IDE is a simple tool that allows users to record browser actions and generate test scripts automatically. While not as powerful as Selenium WebDriver, it’s useful for quick and simple automation or learning.

15. Open Source and Community Support:

Selenium is free to use and has an active community of developers. It is frequently updated, with a wide range of plugins and libraries available for enhancing its capabilities.

Use Cases of Selenium:

  • Web Application Testing: Automating test cases for web applications across browsers.
  • Regression Testing: Running repeated test cases with Selenium scripts to check for regressions in software behavior.
  • Load Testing: Automating simulations of multiple users interacting with a website.
  • Scraping Data: Extracting data from web pages by automating interactions.

Next >>