Selenium with Python is a great way to automate tasks on websites and test web applications. Selenium helps control the browser, while Python makes writing scripts easy and efficient. This combination is widely used for web testing and automation.
In this article, we’ll look at advanced topics like using data-driven tests and creating custom test reports. We’ll show you how these methods can improve your testing process and make it more flexible and detailed. Let’s dig deeper and understand how to utilize Selenium Python effectively for test automation. If you are new to Selenium, explore this detailed guide on What is Selenium?.
Introduction to Selenium and Python
Selenium is one such open-source web automation framework, mostly used for automating web applications for test purposes. It allows test writers to write their test scripts in almost all programming languages, like Java, Python, C#, Ruby, JavaScript, and many more. Using selenium, you can automatically simulate interactions with web browsers – clicking on buttons, text entries, and navigation through websites, among others, to validate the functionality of web applications.
Selenium Automates the actions users perform on a browser. It behaves like an actual user, hence ideal for end-to-end testing scenarios. Selenium Python executes some predefined test cases, unlike manual testing, where a tester interacts with the website. Hence, faster execution and results are also consistent.
Python is a set of instructions written as a Program to direct the computer to perform a specific task. It is a Programming language with features like being interpreted, object-oriented, and high-level. Its beginner-friendly syntax makes it an ideal choice for those starting their programming journey. The primary purpose of its creation is to simplify reading and understanding for developers while minimizing the lines of code. Python has become a leading tool in automation, helping developers break down complex tasks into manageable functions. Python is regarded as an automation powerhouse by developers for several key reasons:
- Ease of Learning
- Conciseness
- Rich Libraries
Selenium Python: Basics
There are two primary methods to run automated tests on web browsers with Python and Selenium Python:
- Utilizing the Selenium WebDriver:
Selenium WebDriver gives automated control of web browsers, and when paired with Python, it helps create test scripts to interact with websites and verify their functionality. The first step is installing the Selenium package via pip, the Python package manager.
Subsequently, you’ll instantiate the WebDriver class within your Python code to control the web browser. Once the test script is ready, execute it using Python’s unit test framework or any other testing framework that provides organizational and execution features for your tests.
- Leveraging the Selenium IDE:
Recorded scripts can be exported to various programming languages, including Python. To run a Selenium IDE script that has been exported in Python, start by installing the Selenium package using pip.
Then, import the essential Selenium modules into your Python script and execute the exported test code. You can run it using Python’s built-in testing framework or other tools. Although the Selenium IDE enables faster script creation by recording interactions, the generated scripts might lack the flexibility and robustness of those written directly using WebDriver.
Prerequisites To Run Selenium Tests With Python
When you install Python, the Selenium libraries are not installed by default. The simplest way to install Selenium for Python is through the pip installer. Follow these steps:
- Open your command prompt or terminal window.
- Go to the directory where Python is installed.
- Type “pip list” to check if the Selenium libraries are installed. This command will display all the Python libraries that have been installed.
Pip stands for “Pip Installs Packages” and comes pre-installed with Python. To install the Selenium libraries, use the following command:
| pip install selenium |
This command will download and install all necessary Selenium libraries for Python.
- After installation, run “pip list” again to verify the Selenium libraries are now listed.
While Selenium installation provides core functionality, you also need additional browser drivers to enable Selenium to control specific web browsers on your system. To download the drivers for the following browsers, visit their official websites:
- Google Chrome
- Microsoft Edge
- Mozilla Firefox
- Apple Safari (Mac only)
Installing these browser drivers will be enough if you’re running Selenium tests locally on your machine.
However, To run Selenium tests for Python on a remote server, you must also download and install the Selenium Server standalone package.
Selenium Python Example: Running Your First Test
Here are the steps to execute your first Selenium Python test using Python:
Step 1: Import the Necessary Classes
Start by importing the essential classes:
| from selenium import webdriver from selenium.webdriver.common.keys import Keys |
- webdriver: Controls the browser.
- Keys: Simulates keyboard actions.
Step 2: Create a WebDriver Instance
Create a WebDriver instance to interact with the browser:
| driver = webdriver.Chrome(‘./chromedriver’) |
Make sure the chromedriver is located in the same directory as your script. This command opens a new Chrome browser window.
Step 3: Load a Website
Navigate to a website using the .get() method:
| driver.get(“https://www.python.org”) |
This opens Python’s official website.
Step 4: Check the Page Title
Retrieve and print the page title to confirm the page has loaded:
| print(driver.title) |
Expected output: Welcome to Python.org
Step 5: Interact with the Search Bar
Find the search bar, enter a query, and submit 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) |
- find_element_by_name(“q”): Locates the search bar.
- clear(): Removes any pre-filled text.
- send_keys(): Types the search query.
- send_keys(Keys.RETURN): Simulates pressing Enter.
Step 6: Verify the Resulting URL
Check the updated URL after the search:
| print(driver.current_url) |
Example URL: https://www.python.org/search/?q=getting+started+with+python&submit=
Step 7: Close the Browser
End the test by closing the browser session:
| driver.close() |
Testing Framework Integration With Selenium
Integrating Selenium Python tests with testing frameworks enhances test organization, provides setup and teardown mechanisms, and generates detailed test reports. Below are examples of integrating Selenium with two popular Python frameworks: unittest and pytest.
Integration with unittest Framework
unittest is a built-in Python testing framework that helps manage test cases and provides test discovery, fixtures, and reports.
Example: Basic Selenium 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 test_search_python(self): # Verify the title contains “Python” @classmethod if __name__ == “__main__”: |
Explanation:
- TestCase: The base class for creating test cases. Each method in the class that starts with test_ is treated as a test.
- setUpClass(): Sets up resources (e.g., browser driver) once before running any tests in the class.
- tearDownClass(): Cleans up resources after all tests have run.
- Assertions: Use self.assertIn() to verify that a condition is true, raising errors if the condition fails.
Integration with pytest Framework
pytest is a flexible testing framework known for its simplicity, detailed assertions, and rich features like fixtures and parameterization.
Example: Basic Selenium 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 test_search_python(driver): # Locate the search bar and perform a search # Verify the title contains “Python” |
Explanation:
- @pytest.fixture: Sets up resources like the WebDriver. Using scope=”module”, the fixture is created once per modulYieldeld: Temporarily pauses the fixture, letting the test run, and then performs cleanup (e.g., closing the browser).
- Assertions: Use simple assert statements for validations. pytest provides detailed error messages when assertions fail.
Implementing Data-Driven Tests
Data-driven tests use external data sources to run the same test with varying inputs. This approach improves coverage and reduces code duplication.
Example: Data-driven tests with pytest and CSV
| import pytest import csv from selenium import webdriver from selenium.webdriver.common.by import By from selenium.webdriver.common.keys import Keys # Data provider function # Fixture for WebDriver # Parameterized test using data from CSV |
Explanation:
- CSV Data: The read_test_data function reads data from a CSV file containing columns like search_query and expected_in_title.
- mark.parametrize: Automatically feeds the data rows to the test, running it multiple times with different inputs.
- Assertions: Validates that the search query produces the expected result in the page title.
Generating Custom Test Reports
Custom reports provide detailed insights into test results, helping teams analyze failures and successes.
Example: Generating HTML Reports with pytest-html
pytest-html is a plugin that generates an HTML report after the tests.
Install pytest-html:
| pip install pytest-html |
Run Tests with HTML Report: Add the –html option to generate a report.
| pytest test_file.py –html=report.html |
Customize the Report: Add metadata and screenshots for failed tests.
| import pytest from selenium import webdriver from selenium.webdriver.common.by import By @pytest.fixture(scope=”module”) @pytest.hookimpl(tryfirst=True) @pytest.hookimpl(trylast=True) def pytest_runtest_makereport(item, call): def test_google_search(driver): |
Explanation:
- pytest-html Hooks:
- pytest_configure: Adds metadata to the report.
- pytest_html_results_table_row: Embeds screenshots in the report.
- Screenshots on Failure: Captures the browser state when a test fails, providing visual context.
Best Practices for Using Selenium With Python
The following are recommended best practices for automating tests with Selenium Python and Python:
- Organize Tests with Frameworks: Integrate your Selenium tests with frameworks like unittest or pytest. These frameworks help structure test cases, manage setup and teardown processes, and generate detailed test reports, ensuring better organization and scalability of your test suite.
- Handle Exceptions Carefully: Incorporate proper error handling and logging to address unexpected scenarios such as missing elements or timeouts. This practice aids in debugging and provides clear insights into test failures, making it easier to identify and resolve issues.
- Use Explicit Waits: Prefer explicit waits instead of implicit waits when dealing with dynamic content. Explicit waits allow your script to interact with web elements only when they meet specific conditions, reducing the risk of timing-related issues.
- Leverage Cloud Testing Platforms: Leveraging cloud-testing platforms like LambdaTest is an AI-native test orchestration execution platform that lets you perform manual and automated tests at scale across 5000+ browsers and OS combinations
For teams using Selenium for automation, understanding what Selenium WebDriver? becomes crucial. Selenium WebDriver is the core component that allows direct communication between test scripts and web browsers, enabling seamless test execution.
By integrating LambdaTest into your Python Selenium WebDriver testing workflow, you can:
- Remove the need for an in-house Selenium Grid or device lab.
- Use advanced features like parallel test execution, intelligent test orchestration, and real-time debugging.
- Achieve full cross-browser and cross-platform coverage without infrastructure constraints.
- Expand testing efforts effortlessly as your application becomes more complex.
Conclusion
Regardless of how well you grasp the Selenium Python automation framework, its true effectiveness lies in the quality of the tests you design. While automating tests can save time, it’s essential to create tests that cover every possible scenario. Detecting errors early in the testing phase is always better than dealing with customer complaints later.
By implementing well-designed Selenium Python tests across your applications and websites, you can significantly increase your confidence in the software’s quality before release. The initial effort in developing an automated test suite pays off by detecting errors earlier and speeding up testing cycles.
