Selenium is a popular open-source tool for automating browser interactions in web applications. Over the years, the tool has undergone several upgrades, with each version bringing better and improved features that help developers write more efficient and effective tests.
In this article, we’ll discuss two essential topics related to Selenium: executable_path deprecation and using the Service class in Selenium 4.
Executable_Path Deprecation
If you’ve been using Selenium for a while, you’re probably familiar with the executable_path keyword. In previous versions of Selenium, the executable_path keyword was used to specify the location of the browser driver executable.
This approach was sufficient at the time, but as Selenium evolved, it became clear that a more robust solution was needed to manage browser drivers explicitly.
In the latest Selenium 4, the use of executable_path has been deprecated.
This means that if you’re still using the older version, it’s time to switch to the newer Service class. The Service class provides a more unified way of interacting with browsers and their respective web drivers.
It’s an object-oriented approach, which offers better code organization and configuration management.
Using the Service Class
The Service class helps to bridge the gap between browser drivers and Selenium. The class provides a way to start and stop browser drivers programmatically and allows you to configure the browser driver based on your specific needs.
Here’s an example of how to use the Service class with Chromium:
1. Install the required modules:
To use Chromium, you’ll need to make sure you have the necessary modules installed.
Specifically, you’ll need:
– Selenium
– ChromiumDriver
To install these modules, you can use the pip package manager. Open your terminal and run the following commands:
pip install selenium
pip install chromium_driver
2. Configure your service:
Once you’ve installed the required modules, you need to configure your service.
The Service class takes care of starting and stopping browser drivers, but you’ll need to specify the path to the browser driver and any additional options you want to configure. Here’s an example of how to use the Service class to start a Chrome browser:
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium import webdriver
# Set the path to the chromium driver
service = Service(‘/path/to/chromedriver’)
# Set up the browser options
options = Options()
options.add_argument(‘–disable-extensions’)
options.add_argument(‘–headless’)
# Start the browser with the configured service and options
driver = webdriver.Chrome(service=service, options=options)
3. Use the browser:
Once the browser has started, you can use it as you normally would with Selenium.
For example, you can navigate to a page:
driver.get(‘https://www.example.com’)
Or interact with elements:
username = driver.find_element_by_name(‘username’)
username.send_keys(‘myusername’)
Conclusion
In conclusion, while the use of executable_path may have served its purpose in the past, it’s time to switch to the newer Service class in Selenium 4. The Service class provides a more robust and object-oriented approach to interacting with browser drivers, making your tests more organized and manageable.
By following the steps outlined in this article, you’ll be able to use the new Service class with confidence and enjoy the benefits of a more robust and flexible testing environment. Example of Starting a Chrome Instance, Visiting Google, and Typing into the Search Field
Launching a Chrome browser instance, visiting Google, and typing into the search field is a staple example of how to use Selenium.
In this section, we’ll show you how to achieve this using Selenium and Python. 1.
Install Selenium:
To start things off, you’ll need to install Selenium. You can install Selenium using pip, the package manager for Python.
Run the following command in your terminal:
pip3 install selenium
2. Installing the Chromedriver:
The next step is to install the Chromedriver.
The Chromedriver is an executable file that allows Selenium to interface with the Chrome browser. You can download the latest version of Chromedriver from this link – https://chromedriver.chromium.org/downloads.
Once downloaded, extract the file and add it to your PATH. If you’re not sure how to do this, follow this tutorial – https://www.java.com/en/download/help/path.html.
3. Writing the code:
Now that you have everything set up, you’re ready to write your code.
Here’s an example script that opens a Chrome instance, visits Google, and types “Selenium” into the search field:
“`python
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
# Create a new Chrome instance
driver = webdriver.Chrome()
# Navigate to Google.com
driver.get(“https://www.google.com”)
# Find the search field and enter “Selenium”
search_field = driver.find_element_by_name(“q”)
search_field.send_keys(“Selenium”)
search_field.send_keys(Keys.RETURN)
“`
4. Explanation of the code:
The code above does the following:
– import the required libraries – Selenium and Keys
– create a new Chrome instance using the `webdriver.Chrome()` method
– navigate to Google using the `driver.get()` method and passing in the URL of the website
– locate the search field using its `name` HTML attribute with `driver.find_element_by_name()`
– send the text `Selenium` to the search field using the `send_keys()` method
– To submit the search results, use `Keys.RETURN` as shown above.
Alternatively, find the Google search button element using a similar method to the search field above and send a `click()` method to trigger the search. Using the Newer find_element() Method Instead of the Deprecated find_element_by_* Method
Selenium has several commands that allow you to find web page elements so you can interact with them in your tests.
In previous versions of Selenium (pre-Selenium 4), the most commonly used commands started with `find_element_by_`. For example, `find_element_by_id`, `find_element_by_name`, `find_element_by_xpath`, etc.
However, these commands have since been deprecated and replaced with a new and improved `find_element()` method. The new method is more expressive and allows you to locate elements using different methods other than the hardcoded options like tags, css selectors, classes, etc.
Here are some examples of how to use the newer `find_element()` method:
“`python
from selenium import webdriver
from selenium.webdriver.common.by import By
# Locate element by ID
element = driver.find_element(By.ID, “my-id”)
# Locate element by name
element = driver.find_element(By.NAME, “my-name”)
# Locate element by class name
element = driver.find_element(By.CLASS_NAME, “my-class”)
# Locate element by CSS selector
element = driver.find_element(By.CSS_SELECTOR, “my-css-selector”)
# Locate element by XPath
element = driver.find_element(By.XPATH, “my-xpath”)
“`
In the example above, we’ve used the `By` class to locate elements based on different attributes like `id`, `name`, `class name`, `CSS selector`, and `XPath`. The `find_element()` method takes two arguments- the attribute to search for, and the value of the attribute.
Conclusion
In conclusion, updating to the latest versions of Selenium will give you access to the latest and robust features to help you develop a more functional and efficient test suite. We’ve shown you how to write basic scripts for opening Google Chrome, navigating to Google, and inputting text in the search field for automation purposes.
We’ve also shown you how to use the new `find_element()` method instead of the deprecated `find_element_by_*` methods. With these tools and techniques at your disposal, you’ll be well on your way to writing efficient Selenium tests.
Selenium is continuously updating and adding new features to improve the testing experience, making some features deprecated. One of the most commonly deprecated features in Selenium is the `find_element_by_*` command.
This command was used to identify web page elements by using predefined attributes such as IDs, class names, and more. The command is no longer the best approach, and as a result, new methods have been introduced.
In this section, we’ll look at the deprecated `find_element_by_*` methods and the newer `find_element()` method and how to replace them. Deprecated find_element_by_* Methods:
1.
find_element_by_id:
The `find_element_by_id` method is deprecated. Instead, use `find_element(By.ID, value)` to locate an element by its ID attribute.
Here’s an example:
“`python
# Deprecated method
element = driver.find_element_by_id(“search”)
# Newer method
element = driver.find_element(By.ID, “search”)
“`
2. find_element_by_name:
The `find_element_by_name` method is deprecated.
Instead, use `find_element(By.NAME, value)` method to locate an element by its name attribute. Here’s an example:
“`python
# Deprecated method
element = driver.find_element_by_name(“search”)
# Newer method
element = driver.find_element(By.NAME, “search”)
“`
3.
find_element_by_class_name:
The `find_element_by_class_name` method is deprecated. Instead, use `find_element(By.CLASS_NAME, value)` to locate an element by its class name attribute.
Here’s an example:
“`python
# Deprecated method
element = driver.find_element_by_class_name(“search”)
# Newer method
element = driver.find_element(By.CLASS_NAME, “search”)
“`
4. find_element_by_tag_name:
The `find_element_by_tag_name` method is deprecated.
Instead, use `find_element(By.TAG_NAME, value)` to locate an element by its tag name attribute. Here’s an example:
“`python
# Deprecated method
element = driver.find_element_by_tag_name(“input”)
# Newer method
element = driver.find_element(By.TAG_NAME, “input”)
“`
5.
find_element_by_link_text:
The `find_element_by_link_text` method is deprecated. Instead, use `find_element(By.LINK_TEXT, value)` to locate an element by its link text attribute.
Here’s an example:
“`python
# Deprecated method
element = driver.find_element_by_link_text(“Click here”)
# Newer method
element = driver.find_element(By.LINK_TEXT, “Click here”)
“`
6. find_element_by_partial_link_text:
The `find_element_by_partial_link_text` method is deprecated.
Instead, use `find_element(By.PARTIAL_LINK_TEXT, value)` to locate an element by its partial link text attribute. Here’s an example:
“`python
# Deprecated method
element = driver.find_element_by_partial_link_text(“link”)
# Newer method
element = driver.find_element(By.PARTIAL_LINK_TEXT, “link”)
“`
Newer find_element() Method:
The newer `find_element()` method is an improved approach to locating web elements on web pages, and the syntax is simpler and more expressive.
The current `find_element()` method takes in two arguments: the method to use for locating the element and the value of the attribute that needs to be found. Using the newer `find_element()` method is crucial, especially when updating your Selenium code for future versions.
Here’s an example:
“`python
# Find element by class name
element = driver.find_element(By.CLASS_NAME, “example-class”)
“`
The method returns one element, and you can use this element to interact with the web element as usual.
Conclusion:
In conclusion, using a deprecated method for locating web elements in Selenium can lead to errors, and that’s why newer methods have been introduced to improve the testing experience. We’ve covered several deprecated methods and their newer alternatives- the `find_element()` method.
Although there’s no immediate pressure to update your Selenium codebase, using newer methods in place of deprecated methods will enhance your test scripts and help you write more stable, maintainable, and efficient code. With these methods, replacing deprecated methods with the current method is as easy as replacing the method signature while providing the same attribute arguments to locate the element.
In summary, to keep up with the updates and features of Selenium, it is important to replace deprecated methods with newer, more efficient methods, such as the `find_element()` method. The article has covered how to replace deprecated `find_element_by_*` methods with the new method, making your test scripts maintainable and less prone to errors.
Using the newer `find_element()` method is a crucial step that ensures your Selenium code is up-to-date. By incorporating this change, you can write efficient and effective test automation scripts.
Remember to keep updating your Selenium code to stay up-to-date and ensure your automation code is reliable and maintainable.