Selenium Python Tutorial (with Example)

New features are regularly added to web applications to boost user engagement. To ensure these updates work as intended and that the user interface remains functional, automated testing is crucial. Selenium is a widely-used tool for this type of automation testing.

Selenium is an open-source automation testing tool that supports various scripting languages such as C#, Java, Perl, Ruby, JavaScript, and others. The choice of scripting language can be made based on the specific requirements of the application being tested.

Python is one of the most popular choices when it comes to scripting with 51% of the developers using it, as suggested by the StackOverflow 2024 annual survey.

Why do Developers prefer Python for writing Selenium Test Scripts?

Developers prefer Python for writing Selenium test scripts because of its simplicity, readability, and ease of use. Python’s clear and concise syntax allows for faster script development and easier maintenance, which is crucial in testing scenarios.

Additionally, Python has a rich set of libraries and frameworks that complement Selenium, making it easier to handle complex tasks such as data manipulation, reporting, and integration with other tools.

Python’s extensive community support and documentation also provide valuable resources for troubleshooting and improving test scripts. These factors make Python a popular choice for Selenium automation.

Getting Started with Selenium Python

Getting started with Selenium using Python involves setting up an environment where you can write and run automated test scripts for web applications.

Selenium, combined with Python, offers a powerful and easy-to-learn toolset for automating browser interactions. Python’s simple syntax makes it ideal for quickly writing clear and maintainable test scripts.

To begin, you’ll need to install the Selenium WebDriver, set up a compatible browser, and learn the basics of locating web elements, interacting with them, and running test cases. This combination is perfect for testing dynamic and responsive web applications efficiently.

What is Selenium WebDriver

Selenium WebDriver is the core component that drives the browser for automation. It acts like a remote control, allowing scripts to open pages, click buttons, fill forms, and check results, just like a real user would. Each major browser (such as Chrome, Firefox, and Edge) has its own version of the WebDriver to ensure compatibility and control.

What Are Selenium Python Bindings?

Selenium Python bindings are a set of libraries that let Python interact with Selenium WebDriver. These libraries provide the tools and commands needed to control a web browser using Python code. In simple terms, the bindings act as a bridge between Selenium’s core functions and Python. They allow test scripts written in Python to open web pages, click buttons, enter text, and check results, just like how a real user would do in the browser.

The Python bindings are officially supported by the Selenium team and are easy to install using pip. Once installed, they make it possible to write powerful browser automation scripts using clean and readable Python syntax.

Selenium Python Example: How to run your first Test?

To run Selenium Python Tests here are the steps to follow:

Step 1. Import the Necessary Classes

First, you’ll need to import the WebDriver and Keys classes from Selenium. These classes help you interact with a web browser and emulate keyboard actions.

from selenium import webdriver

from selenium.webdriver.common.keys import Keys

webdriver: Allows you to control the browser.
Keys: Lets you simulate keyboard key presses.

Step 2. Create a WebDriver Instance

To interact with a browser, you’ll need to create an instance of WebDriver. In this example, we use Chrome:

driver = webdriver.Chrome('./chromedriver')

Make sure chromedriver is in the same directory as your Python script. This command opens a new Chrome browser window.

Step 3. Load a Website

Use the .get() method to navigate to a website. This method waits for the page to load completely:

driver.get("https://www.python.org")

This will open Python’s official website in the browser.

Step 4. Check the Page Title

Once the page is loaded, you can retrieve and print the page title to verify you’re on the right page:

print(driver.title)

You should see:

Welcome to Python.org

Step 5. Interact with the Search Bar

To perform a search, locate the search bar element, enter a query, and submit it. Here’s how to find the search bar by its name attribute and interact with it:

search_bar = driver.find_element_by_name("q")

search_bar.clear()

search_bar.send_keys("getting started with python")

search_bar.send_keys(Keys.RETURN)

As an explanation :

find_element_by_name(“q”): Finds the search bar element.
clear(): Clears any existing text.
send_keys(“getting started with python”): Types the query into the search bar.
send_keys(Keys.RETURN): Simulates pressing the Return (Enter) key.

Step 6. Verify the Resulting URL

After submitting the search query, you can check the updated URL to confirm the search results page:

print(driver.current_url)

You should see a URL similar to:

https://www.python.org/search/?q=getting+started+with+python&submit=

Step 7. Close the Browser

Finally, close the browser session to end the test:

driver.close()

Summary :

Here is the complete script for your first Selenium test in Python. Save this code in a file named selenium_test.py and run it using python selenium_test.py:

from selenium import webdriver

from selenium.webdriver.common.keys import Keys



# Create a new instance of the Chrome driver

driver = webdriver.Chrome('./chromedriver')



# Open the Python website

driver.get("https://www.python.org")



# Print the page title

print(driver.title)



# Find the search bar using its name attribute

search_bar = driver.find_element_by_name("q")

search_bar.clear()

search_bar.send_keys("getting started with python")

search_bar.send_keys(Keys.RETURN)



# Print the current URL

print(driver.current_url)



# Close the browser window

driver.close()

Also Read: How to run Selenium tests on Chrome using ChromeDriver

Interacting with Common Elements in Selenium

Selenium allows you to perform a variety of actions on web elements. You have already touched upon entering input, here’s how to interact with buttons, and dropdowns:

Assuming you want to click a button with the ID “submit-button” after entering the input in the search bar :

# Locate the button by its ID attribute

button = driver.find_element_by_id("submit-button")



# Click the button

button.click()

If you need to click a link by its text:

# Locate the link by its link text

link = driver.find_element_by_link_text("Click Here")



# Click the link

link.click()

Explanation:

find_element_by_id(“submit-button”): Finds the button with the ID “submit-button”.
find_element_by_link_text(“Click Here”): Finds a link with the text “Click Here”.
click(): Simulates a mouse click on the element.

Though dropdowns are not present on this site, they are quite common for web application testing

For dropdown menus, Selenium provides the Select class to handle options within <select> elements.

Example: Selecting an Option from a Dropdown

Assuming you have a dropdown menu with the ID “dropdown-menu”:

from selenium.webdriver.support.ui import Select



# Locate the dropdown menu by its ID attribute

dropdown = Select(driver.find_element_by_id("dropdown-menu"))




# Select an option by visible text

dropdown.select_by_visible_text("Option 1")


# Or select an option by value

dropdown.select_by_value("option1")



# Or select an option by index (0-based index)

dropdown.select_by_index(0)

Explanation:

Select(driver.find_element_by_id(“dropdown-menu”)): Creates a Select object for the dropdown menu.
select_by_visible_text(“Option 1”): Selects an option by its visible text.
select_by_value(“option1”): Selects an option by its value attribute.
select_by_index(0): Selects an option by its index in the dropdown.

Navigate through HTML DOM Elements

The HTML Document Object Model (DOM) represents the structure of a web page as a tree of objects. Selenium allows you to interact with these elements using various locator strategies.

In our first test script, we have already used some of the methods used to navigate DOM elements. This section will be a slightly more detailed view into how you can use different methods to locate and interact with elements on the Python.org website.

Step 1. Locate and Interact with Navigation Links

Let’s consider an example: Clicking the ‘Downloads’ link

To click the “Downloads” link, you can use the .find_element_by_link_text() method, but here’s how to use other locators to achieve the same, example by using find_element_by_xpath:

from selenium import webdriver



# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')



# Open the Python website

driver.get("https://www.python.org/")



# Locate the "Downloads" link using XPath

downloads_link = driver.find_element_by_xpath("//a[text()='Downloads']")



# Click the "Downloads" link

downloads_link.click()



# Optionally, print the current URL to confirm navigation

print(driver.current_url)



# Close the browser

driver.close()

Explanation:

XPath: //a[text()='Downloads']

locates the “Downloads” link based on its visible text.

Step 2. Access and Interact with Header Sections

Let’s consider an example: Accessing the Main Header

To access the main header text, you can use different locators to find the header element.

Using find_element_by_class_name:

from selenium import webdriver



# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')



# Open the Python website

driver.get("https://www.python.org/")



# Locate the header element using its class name

header = driver.find_element_by_class_name("introduction")



# Print the text of the header

print(header.text)



# Close the browser

driver.close()

Explanation:

Class Name: “introduction” is used to find the header element based on its class.

Step 3. Interact with Forms and Input Fields

Let’s consider an example: Filling Out and Submitting the Search Form

To interact with the search form, you can use the .find_element_by_name() method to locate the input field.

Using find_element_by_name:

from selenium import webdriver

from selenium.webdriver.common.keys import Keys



# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')



# Open the Python website

driver.get("https://www.python.org/")



# Locate the search bar using its name attribute

search_bar = driver.find_element_by_name("q")



# Clear any existing text and enter a new search term

search_bar.clear()

search_bar.send_keys("Python Documentation")

search_bar.send_keys(Keys.RETURN)



# Optionally, print the current URL to confirm search results

print(driver.current_url)



# Close the browser

driver.close()

Explanation:

Name Attribute: find_element_by_name(“q”) locates the search input field by its name attribute.

Navigate through Windows and Frames

When working with multiple browser windows or tabs, or dealing with iframes (frames), you may need to switch contexts to interact with different elements.

Step 1. Handling Multiple Browser Windows or Tabs

Let’s consider an example: Switching Between Windows

To handle multiple browser windows or tabs:

from selenium import webdriver

from selenium.webdriver.common.keys import Keys

import time



# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')



# Open the Python website

driver.get("https://www.python.org/")



# Open a new tab with a different URL

driver.execute_script("window.open('https://www.google.com', '_blank');")



# Switch to the new tab

driver.switch_to.window(driver.window_handles[1])



# Perform actions in the new tab (e.g., search for 'Selenium')

search_bar = driver.find_element_by_name("q")

search_bar.clear()

search_bar.send_keys("Selenium")

search_bar.send_keys(Keys.RETURN)



# Switch back to the original tab

driver.switch_to.window(driver.window_handles[0])



# Close the browser

driver.quit()

Explanation:

window_handles: Retrieves a list of window handles. Switch to a specific window using switch_to.window().
execute_script(“window.open()”): Opens a new tab or window.

Step 2. Switching Between Frames

Let’s consider an example: Switching to an iFrame

To switch to and interact with elements within an iframe:

from selenium import webdriver

from selenium.webdriver.common.keys import Keys

import time



# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')



# Open the Python website

driver.get("https://www.python.org/")



# Example site with iframe (replace with an actual URL that contains iframes)

driver.get("https://www.w3schools.com/html/html_iframe.asp")



# Switch to the iframe using its name or ID

driver.switch_to.frame("iframeResult")



# Perform actions within the iframe

print(driver.find_element_by_tag_name("h1").text)



# Switch back to the default content

driver.switch_to.default_content()



# Close the browser

driver.quit()

Explanation:

switch_to.frame(): Switches to a specific iframe.
switch_to.default_content(): Switches back to the main page.

Handling Waits in Selenium Python

Web applications often include dropdown menus (also known as select boxes) to let users choose an option from a list. Selenium provides a straightforward way to interact with these using the Select class.

Working with Dropdown Menus

To handle dropdowns, Selenium uses the Select class from the selenium.webdriver.support.ui module. This class allows selecting options by visible text, index or value.

from selenium import webdriver

from selenium.webdriver.common.by import By

from selenium.webdriver.support.ui import Select




# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')




# Open a website with a dropdown (example URL)

driver.get("https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_select")




# Switch to the iframe containing the dropdown

driver.switch_to.frame("iframeResult")




# Locate the dropdown element

dropdown_element = driver.find_element(By.ID, "cars")




# Create a Select object

dropdown = Select(dropdown_element)




# Select an option by visible text

dropdown.select_by_visible_text("Volvo")




# Select an option by value

dropdown.select_by_value("saab")




# Select an option by index (starting at 0)

dropdown.select_by_index(2)




# Close the browser

driver.quit()

Explanation:

Select(element): Creates a Select object linked to the dropdown element.
select_by_visible_text(“text”): Chooses the option that matches the visible label.
select_by_value(“value”): Chooses based on the HTML value attribute.
select_by_index(n): Chooses the option at a specific position in the list.

Other Dropdown Actions:

dropdown.options: Returns all available options as a list.
dropdown.first_selected_option: Gets the currently selected option.

Dynamic content can load at different times, so using waits helps ensure elements are present before interacting with them.

Step 1. Implicit Waits

Example: Using Implicit Waits

from selenium import webdriver



# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')



# Set implicit wait

driver.implicitly_wait(10)  # seconds



# Open the Python website

driver.get("https://www.python.org/")



# Locate an element with implicit wait

search_bar = driver.find_element_by_name("q")

search_bar.send_keys("Python")



# Close the browser

driver.quit()

Explanation:

implicitly_wait(): Sets a default wait time for finding elements. If an element is not immediately found, WebDriver will wait up to the specified time.

Step 2. Explicit Waits

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



# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')



# Open the Python website

driver.get("https://www.python.org/")



# Define WebDriverWait with a maximum wait time of 10 seconds

wait = WebDriverWait(driver, 10)



# Wait for the search bar to be present in the DOM

search_bar = wait.until(EC.presence_of_element_located((By.NAME, "q")))



# Perform actions on the search bar

search_bar.send_keys("Python")



# Close the browser

driver.quit()

Explanation:

WebDriverWait(driver, 10): Creates an instance of WebDriverWait, specifying a maximum wait time of 10 seconds.
wait.until(EC.presence_of_element_located((By.NAME, “q”))): Pauses the script until the search bar element is found by its name attribute. If the element is not found within 10 seconds, a TimeoutException will be raised.

Must Read: How to use Wait commands in Selenium WebDriver

Assertions and Validations

To ensure that the application behaves as expected, you can use assertions and validations.

Verifying Expected Conditions Using Assertions

Example: Verifying Page Title and Search Results

from selenium import webdriver

from selenium.webdriver.common.keys import Keys

from selenium.webdriver.support.ui import WebDriverWait

from selenium.webdriver.support import expected_conditions as EC



# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')



# Open the Python website

driver.get("https://www.python.org/")



# Use WebDriverWait to wait for the search bar to be present

wait = WebDriverWait(driver, 10)

search_bar = wait.until(EC.presence_of_element_located((By.NAME, "q")))



# Perform search

search_bar.send_keys("Python")

search_bar.send_keys(Keys.RETURN)



# Verify the title contains "Python"

assert "Python" in driver.title



# Verify search results contain expected text

results = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "ul.list-recent-events")))

assert "Python" in results.text



# Print the results to verify

print(driver.title)

print(results.text)



# Close the browser

driver.quit()

Explanation:

Assertions: Used to check if the conditions are met. For example, checking if the title or text of elements matches expected values.
assert: Verifies conditions and will raise an AssertionError if the condition is not true.

Handling Alerts and Pop-ups

Web applications often use JavaScript alerts, confirmation dialogs, or prompts to interact with users. Selenium provides ways to handle these pop-ups effectively.

Dealing with JavaScript Alerts

JavaScript alerts are simple pop-up messages that require user interaction to dismiss. Selenium allows you to interact with these alerts using the switch_to.alert() method.

from selenium import webdriver

from selenium.webdriver.common.by import By

from selenium.webdriver.common.keys import Keys



# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')



# Open a website that triggers an alert (example URL)

driver.get("https://www.selenium.dev/selenium/docs/api/java/org/openqa/selenium/Alert.html")



# Click a button that triggers an alert

trigger_alert_button = driver.find_element(By.ID, "alertButton")  # Adjust locator as needed

trigger_alert_button.click()



# Switch to the alert and accept it

alert = driver.switch_to.alert

print("Alert text:", alert.text)

alert.accept()



# Close the browser

driver.quit()

Explanation:

switch_to.alert: Switches the context to the alert. Once switched, you can interact with the alert.
alert.accept(): Accepts the alert, which is equivalent to clicking “OK” on the alert.

Other Alert Actions:

alert.dismiss(): Clicks “Cancel” on a confirmation dialog.
alert.send_keys(“text”): Sends text to a prompt dialog (if applicable).

Handling Checkboxes in Selenium Python

Checkboxes are commonly used in forms to let users select one or more options. Selenium makes it simple to locate, check, or uncheck these boxes using standard element interaction methods.

Working with Checkboxes

Selenium interacts with checkboxes using the click() method. Before clicking, it’s good practice to check whether the box is already selected to avoid unwanted toggling.

from selenium import webdriver

from selenium.webdriver.common.by import By




# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')




# Open a website with checkboxes (example URL)

driver.get("https://www.w3schools.com/howto/howto_css_custom_checkbox.asp")




# Locate the checkbox (adjust locator based on the actual HTML)

checkbox = driver.find_element(By.XPATH, "//input[@type='checkbox']")




# Check if it's already selected

if not checkbox.is_selected():

checkbox.click()  # Check the box




# Uncheck the box (if needed)

if checkbox.is_selected():

checkbox.click()  # Uncheck the box




# Close the browser

driver.quit()

Explanation:

find_element(By.XPATH, …): Locates the checkbox on the page.
is_selected(): Returns True if the checkbox is already checked.
click(): Toggles the checkbox on or off.

Other Checkbox Actions:

Use find_elements() to handle multiple checkboxes in a loop.
Add conditions to check or uncheck based on test logic.

Cleanup and Teardown

Properly closing the browser session is crucial for releasing resources and ensuring that your automation script runs cleanly.

Properly Closing the Browser Session

Example: Closing the Browser

from selenium import webdriver



# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')



# Open a website

driver.get("https://www.python.org/")



# Perform actions (e.g., search)

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

search_bar.send_keys("Python")

search_bar.send_keys(Keys.RETURN)



# Cleanup: Close the browser

driver.quit()

Explanation:

driver.quit(): Closes all browser windows and ends the WebDriver session. This is the preferred method for cleanup as it ensures the browser process is terminated and resources are freed.

Alternative Methods:

driver.close(): Closes the current window. If it’s the only window open, it will end the session. Use driver.quit() for complete cleanup.

Handling Mouse Actions in Selenium Python

Modern web applications often use interactive elements that require advanced mouse actions like hovering, clicking, double-clicking, or dragging and dropping. Selenium handles these interactions using the ActionChains class.

Performing Mouse Actions

The ActionChains class in Selenium allows simulation of complex user gestures. These include hovering over elements, right-clicking, double-clicking and more.

from selenium import webdriver

from selenium.webdriver.common.by import By

from selenium.webdriver.common.action_chains import ActionChains




# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')




# Open a website with interactive elements (example URL)

driver.get("https://swisnl.github.io/jQuery-contextMenu/demo.html")




# Locate the element to interact with

button = driver.find_element(By.CSS_SELECTOR, ".context-menu-one")




# Create an ActionChains object

actions = ActionChains(driver)




# Right-click on the button

actions.context_click(button).perform()




# Hover over the element (if needed)

# actions.move_to_element(button).perform()




# Close the browser

driver.quit()

Explanation:

ActionChains(driver): Creates an object to define a chain of actions.
context_click(element): Performs a right-click on the specified element.
move_to_element(element): Moves the mouse pointer over an element (used for hover actions).
perform(): Executes the entire chain of actions.

Other Mouse Actions:

click(element): Performs a left-click.
double_click(element): Performs a double-click.
drag_and_drop(source, target): Drags an element and drops it onto another.

Locating WebElements in Selenium Python

Before interacting with elements on a web page such as clicking a button, entering text or reading content, Selenium needs to locate those elements accurately. This is done using locators, which are strategies to identify elements within the HTML structure.

Common Ways to Locate Elements

Selenium offers several methods to find elements using the By class from selenium.webdriver.common.by. Each method targets a different attribute or structure in the HTML.

from selenium import webdriver

from selenium.webdriver.common.by import By




# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')




# Open a sample web page

driver.get("https://www.google.com")




# Locate by Name (for Google search input field)

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




# Locate by Tag Name (for Google search button)

element_by_tag = driver.find_element(By.TAG_NAME, "input")




# Locate by Link Text (for the "Google Search" link on Google's footer)

element_by_link_text = driver.find_element(By.LINK_TEXT, "Google")




# Locate by Partial Link Text (for part of the footer link)

element_by_partial_link = driver.find_element(By.PARTIAL_LINK_TEXT, "Search")




# Locate by CSS Selector (for the search input box)

element_by_css = driver.find_element(By.CSS_SELECTOR, "input[name='q']")




# Locate by XPath (for the search button)

element_by_xpath = driver.find_element(By.XPATH, "//input[@name='btnK']")




# Close the browser

driver.quit()

Explanation:

By.ID: Targets an element with a specific id.
By.NAME: Targets an element with a given name attribute.
By.CLASS_NAME: Targets an element using the class value.
By.TAG_NAME: Useful for finding elements like <button>, <input>, or <a>.
By.LINK_TEXT and By.PARTIAL_LINK_TEXT: Used to locate links by visible text.
By.CSS_SELECTOR: A powerful method to find elements using CSS rules.
By.XPATH: Allows precise and complex element selection using XML-like path expressions.

Other Locator Tips:

find_element() returns a single match.
find_elements() returns a list of matches, useful for handling multiple similar elements.

Handling iFrames in Selenium Python

Some web pages include content embedded inside inline frames (iFrames). These iFrames act like separate HTML documents within the main page. To interact with elements inside an iFrame, Selenium must first switch its focus to that frame.

Working with iFrames

Selenium provides methods to switch to an iFrame before accessing its elements. Once done, it can switch back to the main content using switch_to.default_content().

from selenium import webdriver

from selenium.webdriver.common.by import By




# Set up the WebDriver

driver = webdriver.Chrome('./chromedriver')




# Open a page with an iframe

driver.get("https://www.w3schools.com/html/tryit.asp?filename=tryhtml_iframe")




# Switch to the iframe by name or ID

driver.switch_to.frame("iframeResult")




# Locate an element inside the iframe

paragraph = driver.find_element(By.TAG_NAME, "p")

print("Paragraph text inside iframe:", paragraph.text)




# Switch back to the main page content

driver.switch_to.default_content()




# Close the browser

driver.quit()

Explanation:

switch_to.frame(“name_or_id”): Switches Selenium’s focus to the specified iFrame using its name or id.
switch_to.frame(index): Switches to an iFrame based on its position (0 for the first one).
switch_to.frame(webelement): Switches using a reference to the actual frame element.
switch_to.default_content(): Returns control to the main page outside the iFrame.

Other iFrame Handling Tips:

Always switch to the correct frame before interacting with inner elements.
Use driver.find_elements(By.TAG_NAME, “iframe”) to list all frames on a page.
Be cautious of nested iFrames. Multiple switch_to.frame() calls may be needed.

Testing Framework Integration

Integrating Selenium tests with a testing framework provides structured test cases, reporting, and additional functionality such as setup and teardown methods.

1. Integrate with unittest Framework

unittest is a built-in Python testing framework that provides a structured approach to writing and running tests, including test case management, fixtures, and test discovery. Integrating Selenium with unittest allows for organized test cases, setup and teardown methods, and detailed test reports, making it easier to manage and maintain automated tests.

Example: Basic Test with unittest

import unittest

from selenium import webdriver

from selenium.webdriver.common.by import By

from selenium.webdriver.common.keys import Keys



class PythonOrgSearchTest(unittest.TestCase):



    @classmethod

    def setUpClass(cls):

        cls.driver = webdriver.Chrome('./chromedriver')

        cls.driver.get("https://www.python.org/")



    def test_search_python(self):

        search_bar = self.driver.find_element(By.NAME, "q")

        search_bar.send_keys("Python")

        search_bar.send_keys(Keys.RETURN)

        self.assertIn("Python", self.driver.title)



    @classmethod

    def tearDownClass(cls):

        cls.driver.quit()



if __name__ == "__main__":

    unittest.main()

Explanation:

unittest.TestCase: Defines a test case class. Each method within the class represents a test case.
setUpClass(): Initializes resources needed for the tests. Runs once before any test methods are executed.
tearDownClass(): Cleans up resources. Runs once after all test methods have completed.
unittest.main(): Runs the tests and provides output in the console.

2. Integrate with pytest Framework

pytest is a powerful and flexible Python testing framework that simplifies writing tests with its rich feature set, including fixtures, parameterized tests, and detailed assertions. Integrating Selenium with pytest enhances test organization, facilitates advanced setup/teardown functionality, and generates comprehensive test reports, improving test reliability and clarity.

Example: Basic Test with pytest

import pytest

from selenium import webdriver

from selenium.webdriver.common.by import By

from selenium.webdriver.common.keys import Keys



@pytest.fixture(scope="module")

def driver():

    driver = webdriver.Chrome('./chromedriver')

    yield driver

    driver.quit()



def test_search_python(driver):

    driver.get("https://www.python.org/")

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

    search_bar.send_keys("Python")

    search_bar.send_keys(Keys.RETURN)

    assert "Python" in driver.title

Explanation:

pytest.fixture(): Defines a fixture that sets up and tears down resources. The scope=”module” ensures the fixture is run once per module.
yield: Provides the driver instance to the test function and performs cleanup after the test completes.
assert: Checks that the condition is met. pytest will report the assertion failure if the

Run Selenium Python Tests on Real Devices

Best Practices using Selenium WebDriver with Python

Here are five best practices for using Selenium WebDriver with Python:

Use Explicit Waits: Prefer explicit waits over implicit waits to handle dynamic content. Explicit waits ensure that your script interacts with elements only when they are ready, reducing the chances of encountering timing issues.
Organize Tests with Frameworks: Integrate Selenium tests with testing frameworks like unittest or pytest to structure your test cases, manage setup and teardown, and generate detailed test reports.
Use Page Object Model (POM): Implement the Page Object Model to separate test logic from page-specific code. This design pattern promotes code reusability, maintainability, and easier updates.
Handle Exceptions Carefully: Implement error handling and logging to manage unexpected situations, such as element not found or timeout errors. This helps in debugging and provides insights into test failures.
Optimize Browser Performance: Run tests in headless mode or use browser profiles to speed up test execution and reduce resource consumption. Also, ensure that browser drivers are up-to-date for compatibility and performance improvements.

Why run Selenium Python Tests on BrowserStack Real Device Cloud?

Running Selenium Python tests on BrowserStack’s Real Device Cloud offers numerous advantages that significantly enhance testing efficiency and effectiveness.

BrowserStack provides access to a wide range of real devices and browsers, ensuring that tests reflect real-world scenarios and uncover device-specific issues. The platform supports scalable parallel execution, allowing multiple tests to run simultaneously across various configurations, which accelerates the development cycle.

Cross-platform testing on BrowserStack ensures consistent application performance across different environments. Additionally, it offers real-time debugging features such as live logs, screenshots, and video recordings, which aid in quick troubleshooting.

Seamless integration with CI/CD pipelines further automates the testing process, enabling tests to run on every code change and providing immediate feedback on application quality. Overall, BrowserStack Automate enables comprehensive, efficient, and reliable testing, fostering continuous development and deployment.

Talk to an Expert

Conclusion

Running Selenium Python tests on BrowserStack’s real device cloud improves testing efficiency by providing access to 3500+ real devices and browsers. It supports scalable parallel test execution, cross-browser testing, and real-time debugging with logs, screenshots, and video recordings. Seamless CI/CD integration ensures automated, fast feedback on every code change, enabling reliable and continuous testing.

Useful Resources for Selenium and Python

Automation Tests on Real Devices & Browsers

Seamlessly Run Automation Tests on 3500+ real Devices & Browsers

Selenium Python Tutorial (with Example)