Das ist eine für den Ausdruck optimierte Ansicht des gesamten Kapitels inkl. Unterseiten. Druckvorgang starten.

Zur Standardansicht zurückkehren.

Erste Schritte

If you are new to Selenium, we have a few resources that can help you get up to speed right away.

Diese Seite wird von Englisch auf Deutsch übersetzt. Sprichst Du Deutsch? Hilf uns die Seite zu übersetzen indem Du uns einen Pull Reqeust schickst!

Selenium unterstützt das Automatisieren aller wichtigsten Webbrowser durch die Verwendung von WebDriver.

WebDriver ist eine API und ein Protokoll, das eine programmiersprachen unabhängige Schnittstelle definiert um den Webrowser zu steuern. Jeder Browser ist mit einer spezifischen Implementierung des Webdriver ausgestattet, auch driver genannt. Dieser driver ist die Komponente die verantwortlich ist um den Browser fernzusteuern, weiters handabt dieser die Kommunikation zwischen Selenium und dem Webbrowser.

Diese Trennung wurde bewusst gemacht, um die Verantwortung der browserspezifischen Implementierung in die Hände der Browserhersteller zu legen. Selenium ermöglicht es diese Drittanbieter driver zu verwenden. Weiters werden auch eigene driver zur Verfügung gestellt die durch das Projekt gewartet werden, für den Fall das der Browserhersteller keine zur Verfügung stellt.

Das Seleniumframework verbindet diese einzelnen Komponenten zu einer benutzerfreundlichen Schnittstelle die es ermöglicht, die verschiedenen Browserbackends einheitlich und browser- als auch plattform-unabhängig zu automatisieren.

Die Installation von Selenium unterscheidet sich grundlegend von der Installation kommerzieller Tools. Um Selenium in Deinem Automationsprojekt zu verwenden, ist es notwendig zuerst die entsprechenden Bibliotheken der verwendeten Programmiersprache zu installieren. Weiters benötigst Du die passenden WebDriver Dateien entsprechend des verwendeten Browsers, der für die Automation benötigt, und auf dem die Tests ausgeführt werden.

Installing Selenium can be divided in three steps:

  1. Installing the Selenium library for your desired programming language
  2. Set up the browser driver to automate your browser (e.g. GeckoDriver for Firefox)
  3. (Optional) Set up and configure Selenium Grid if you want to scale up your tests

If you wish to start with a low-code/record and playback tool, please check Selenium IDE

After completing the setup, you can run the code snippet shown at the starting page in our docs. Then head to the WebDriver section to learn more about browser automation with Selenium.

1 - Bibliotheken installieren

Setting up the Selenium library for your favourite programming language.

Diese Seite wird von Englisch auf Deutsch übersetzt. Sprichst Du Deutsch? Hilf uns die Seite zu übersetzen indem Du uns einen Pull Reqeust schickst!

Zu Beginn ist es notwendig das die Selenium Bindings für Dein Automationsprojekt installiert werden. Der Installationsprozess ist von der gewählten Programmiersprache abhängig.

Java

Die Installation der Selenium Bibliotheken für Java kann mit Hilfe von Maven erfolgen. Füge in Deinem Projekt in die pom.xml die selenium-java dependecy hinzu.

<dependency>
  <groupId>org.seleniumhq.selenium</groupId>
  <artifactId>selenium-java</artifactId>
  <version>4.X</version>
</dependency>

Mit der selenium-java dependency ist es möglich Tests laufen zu lassen in allen von Selenium unterstützen Browsern. Falls Du Test nur in einem spezifischen Browser ausführen möchtest, ist es möglich auch nur die dependecy für den gewählten Browser in der pom.xml hinzuzufügen.

Wenn Du zum Beispiel Tests nur in Firefox ausführen möchtest, füge folgende dependecy in die pom.xml hinzu:

<dependency>
  <groupId>org.seleniumhq.selenium</groupId>
  <artifactId>selenium-firefox-driver</artifactId>
  <version>4.X</version>
</dependency>

Analog wenn Du die Tests nur in Chrome ausführen möchtest, musst Du folgende dependecy hinzufügen:

<dependency>
  <groupId>org.seleniumhq.selenium</groupId>
  <artifactId>selenium-chrome-driver</artifactId>
  <version>4.X</version>
</dependency>

Python

Die Installation der Selenium Bibliotheken for Phython can mittels pip erfolgen:

pip install selenium

Alternativ kannst Du den PyPI Quellcode (selenium-x.x.x.tar.gz) downloaden und diesen mittels steup.py installieren:

python setup.py install

C#

Die Installation der Selenium Bibliotheken für C# kann mittels NuGet erfolgen:

# Using package manager
Install-Package Selenium.WebDriver
# or using .Net CLI
dotnet add package Selenium.WebDriver

Ruby

Die Selenium Bibliotheken für Ruby können mittels gem installiert werden:

gem install selenium-webdriver

JavaScript

Die Installation der Selenium Bibliotheken für JavaScript kann mit npm durchgeführt werden:

npm install selenium-webdriver

Kotlin

Da es noch keine Implementierung für Kotlin gibt, müssen die Java Bibliothken verwendet werden, diese können analg zu Java mittels maven eingebunden werden.

2 - Installing browser drivers

Setting up your browser to be automated.

Diese Seite wird von Englisch auf Deutsch übersetzt. Sprichst Du Deutsch? Hilf uns die Seite zu übersetzen indem Du uns einen Pull Reqeust schickst!

Mit Hilfe des WebDrivers unterstützt Selenium alle wichtigen Webbrowser wie Chrom(ium), Firefox, Internet Explorer, Edge, Opera und Safari. Wenn möglich wird der Browser mit Hilfe des integrierten Support für Automation gesteuert, nicht für alle Browser existiert diese Möglichkeit der externe Steuerung.

Das Ziel von WebDriver ist es Interaktionen eines echten Benutzers so gut wie möglich mit dem Browser zu simulieren. Die unterschiedlichen Browser unterstützen dies in unterschiedlicher Weise.

Alle Browser haben ein gemeinsames Interface um den Browser zu steuern, sie unterscheiden sich etwas beim Erstellen einer Browsersession. Die Driver-Implementierungen werden von Dritten bereitgestellt, daher sind diese nicht in Selenium enthalten.

Instanzierung des Drivers, Profilmanagement und verschiedene spezifische Browser Einstellungen sind Beispiele für Parameter die unterschiedliche Werte haben können, abhängig von dem verwendeten Browser. Dieser Abschnitt beschreibt die Anforderungen, die notwendig sind, um die unterschiedlichen Browser zu starten.

Hinzufügen der ausführbaren Programme zum PATH

Die meisten Driver benötigen ein eignes ausführbares Programm für Selenium um mit dem Browser zu kommunizieren. Eine Möglichkeit ist es, manuell festzulegen in welchem Ordner sich die ausführbaren Driver-Dateien befinden bevor der WebDriver gestartet wird, allerdings schränkt das die Portabilität ein, da sich die Dateien dann auf jedem Rechner im gleichen Ordner befinden müssen. Alternativ kann man die diese Dateien auch im Repository des Testcodes ablegen.

Wird der Ordner der die WebDriver Programme enthält dem Systempfad hinzugefügt, ist es für Selenium möglich die Driver Dateien zu finden ohne das im Testcode der exakte Ordner angegeben werden muss.

  • Erstelle ein Verzeichnis in dem die ausführbaren Dateien (executeables) abgelegt werden wie z.B. C:\WebDriver\bin oder /opt/WebDriver/bin
  • Füge das Verzeichnis der PATH - Variable hinzu:
    • Unter Windows - Öffne die Eingabeaufforderung als Administrator und führe folgenden Befehl aus um den Ordnerpfad dauerhaft der PATH Variable für alle Benutzer des Rechners hinzuzufügen:
setx PATH "%PATH%;C:\WebDriver\bin"
  • Unter macOS und Linux führe in einem Terminal folgenden Befehl aus:
export PATH=$PATH:/opt/WebDriver/bin >> ~/.profile
  • Nun können die Änderungen getestet werden. Schließe alle geöffneten Eingabebeaufforderungen bzw. Terminals und öffnen dieses erneut. Tippe nun den Namen eines Drivers, der zuvor in dem Ordner abgelegt wurden z.B.:

    chromedriver
    
  • Wenn der ‘PATH’ korrekt konfiguriert ist, dann sollte eine ähnliche Meldung auf der Konsole wie folgt aussehen:

Starting ChromeDriver 2.25.426935 (820a95b0b81d33e42712f9198c215f703412e1a1) on port 9515
Only local connections are allowed.

Mit Hilfe von Ctrl+C beendest Du den Driver und erlangst wieder Kontrolle über das Terminal.

Referenzen

BrowserUnterstützte BetriebssystemeWartungDownloadFehlerticketsystem
Chromium/ChromeWindows/macOS/LinuxGoogleDownloadsIssues
FirefoxWindows/macOS/LinuxMozillaDownloadsIssues
EdgeWindows 10MicrosoftDownloadsIssues
Internet ExplorerWindowsSelenium ProjectDownloadsIssues
SafarimacOS El Capitan und neuereAppleIntegriertIssues
OperaWindows/macOS/LinuxOperaDownloadsIssues

Chromium/Chrome

Um Chrome oder Chromium zu steuern, muss der chromedriver downgeloaded werden und in einem Ordner gespeichert werden der sich im Systempfad befindet.

Unter Linux oder macOS, muss die PATH Umgebungsvariable angepasst werden. Mit folgendem Kommando können die alle Ordner die der PATH-Variable bereits hinzugefügt wurden angezeigt werden (getrennt durch Beistriche):

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

Um den chromedriver dem PATH hinzuzufügen, falls dies noch nicht geschehen ist, beachte das der Ordner dem PATH hinzugefügt werden muss. Der folgende Befehl fügt der PATH Umgebungsvariable den aktuellen Ordnerpfad hinzu (nach dem Doppelpunkt):

$ export PATH="$PATH:/path/to/chromedriver"

Nachdem der chromedriver dem PATH hinzugefügt wurde ist es möglich das chromedriver Programm von jedem Ordner des Rechners zu starten. Um eine Chrome/Chromium Session zu instanzieren können folgende Codezeilen genutzt werden:

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

WebDriver driver = new ChromeDriver();
  
#Simple assignment
from selenium.webdriver import Chrome

driver = Chrome()

from selenium.webdriver import Chrome

with Chrome() as driver:
    #your code inside this indent
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

IWebDriver driver = new ChromeDriver();
  
require "selenium-webdriver"

driver = Selenium::WebDriver.for :chrome
  
const {Builder} = require('selenium-webdriver');

(async function myFunction() {
    let driver = await new Builder().forBrowser('chrome').build();
    //your code inside this block
})();
  
import org.openqa.selenium.WebDriver
import org.openqa.selenium.chrome.ChromeDriver

val driver: WebDriver = ChromeDriver()
  

Zur Erinnerung: es ist notwendig chromedriver dem PATH hinzuzufügen, dies geschiet mit folgendem Befehl:

System.setProperty("webdriver.chrome.driver", "/path/to/chromedriver");
  
Chrome(executable_path='/path/to/chromedriver')
  
new ChromeDriver("/path/to/chromedriver");
  
Selenium::WebDriver::Chrome.driver_path = "/path/to/chromedriver"
  
chrome.setDefaultService(new chrome.ServiceBuilder('path/to/chromedriver').build());
  
System.setProperty("webdriver.chrome.driver", "/path/to/chromedriver")
  

Der chromedriver ist implementiert als WebDriver Remote Server, somit wird dem Browsers mitgeteilt welche Aktionen auszuführen sind, indem die interne Automationsschnittstelle bereitgestellt wird.

Firefox

Als Selenium 3 gestartet ist, hat Mozilla die Implementierung des Firefox Drivers mit dem geckodriver übernommen. Der neue Driver für Firefox wird geckodriver genannt und funktioniert ab Firefox Version 48. Da der Firefox WebDriver noch immer in Entwicklung ist, wird er laufend verbessert.

Die aktuelle Standardmethode um Firefox zu starten ist mit Hilfe des geckodrivers, daher erfolgt die Instanzierung gleich wie mit Selenium 2.

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;

WebDriver driver = new FirefoxDriver();
  
#Simple assignment
from selenium.webdriver import Firefox

driver = Firefox()
#Or use the context manager
from selenium.webdriver import Firefox

with Firefox() as driver:
   #your code inside this indent
  
using OpenQA.Selenium;
using OpenQA.Selenium.Firefox;

IWebDriver driver = new FirefoxDriver();
  
require "selenium-webdriver"

driver = Selenium::WebDriver.for :firefox
  
const {Builder} = require('selenium-webdriver');

(async function myFunction() {
   let driver = await new Builder().forBrowser('firefox').build();
   //your code inside this block
})();
  
import org.openqa.selenium.WebDriver
import org.openqa.selenium.Firefox.FirefoxDriver

val driver: WebDriver = FirefoxDriver()
  

Falls bevorzugt kann der Ordnerpfad statt mit Hilfe der PATH-Variable mit folgenden Programmzeilen definiert werden:

System.setProperty("webdriver.gecko.driver", "/path/to/geckodriver");
  
Firefox(executable_path='/path/to/geckodriver')
  
new FirefoxDriver("/path/to/geckodriver");
  
Selenium::WebDriver::Firefox.driver_path = "/path/to/geckodriver"
  
const firefox = require('selenium-webdriver/firefox');

const serviceBuilder = new firefox.ServiceBuilder("/path/to/geckodriver");

(async function myFunction() {
    let driver = await new Builder()
        .forBrowser('firefox')
        .setFirefoxService(serviceBuilder)
        .build();
        //your code inside this block
})();
  
System.setProperty("webdriver.gecko.driver", "/path/to/geckodriver")
  

Es ist auch möglich den Parameter via Kommandozeile zu übergeben:

mvn test -Dwebdriver.gecko.driver=/path/to/geckodriver

Aktuell ist es möglich den älteren Firefox Driver zu nutzen, dieser ist hat mehr Funktionen, dafür ist es notwendig eine ältere Version von Firefox mit der Version 47.0.1 oder 45 ESR zu installieren. Weiters ist es notwendig die Eigenschaft marionette auf false zu setzen. Neuere Versionen von Firefox sind nicht kompatibel.

Edge

Edge ist Microsoft’s aktuellster Browser, der in Windows 10 und Server 2016 inkludiert ist. Updates für Edge sind in den Updates für Windows inkludiert, somit ist es notwendig den entsprechenden Driver downzuloaden, der kompatibel ist mit der installierten Windows Version (mit passender Buildnummer). Die Edge Entwickler Website] beinhaltet Links zu allen verfügbaren Edgedrivern. Bugs die den Edgedriver betreffen können bei Microsoft eingemeldet werden. Um Tests mit dem Edge laufen zu lassen ohne ein installiertes Windows 10 auf dem eigenen Rechner zu haben, bietet Microsoft freie VMs an, um den Edge Browser zu testen Edge VM Website.

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.edge.EdgeDriver;

WebDriver driver = new EdgeDriver();
  
#Simple assignment
from selenium.webdriver import Edge

driver = Edge()
#Or use the context manager
from selenium.webdriver import Edge

with Edge() as driver:
   #your code inside this indent
  
using OpenQA.Selenium;
using OpenQA.Selenium.Edge;

IWebDriver driver = new EdgeDriver();
  
require "selenium-webdriver"

driver = Selenium::WebDriver.for :edge
  
const {Builder} = require('selenium-webdriver');

(async function myFunction() {
   let driver = await new Builder().forBrowser('MicrosoftEdge').build();
   //your code inside this block
})();
  
import org.openqa.selenium.WebDriver
import org.openqa.selenium.edge.EdgeDriver

val driver: WebDriver = EdgeDriver()
  

Falls der Edge Driver nicht via PATH verfügbar ist, kann der Pfad auch mit Hilfe des Programmcodes definiert werden:

System.setProperty("webdriver.edge.driver", "C:/path/to/MicrosoftWebDriver.exe");
  
Edge(executable_path='/path/to/MicrosoftWebDriver.exe')
  
new EdgeDriver("/path/to/MicrosoftWebDriver.exe");
  
Selenium::WebDriver::Edge.driver_path = "C:/path/to/MicrosoftWebDriver.exe"
  
const {Builder} = require("selenium-webdriver");
const edge = require('selenium-webdriver/edge');
let service = new edge.ServiceBuilder("/path/to/msedgedriver.exe");
(async function test() {
    let driver = await new Builder()
                .setEdgeService(service)
                .forBrowser('MicrosoftEdge')
                .build();
})();
  
System.setProperty("webdriver.edge.driver", "C:/path/to/MicrosoftWebDriver.exe")
  

Internet Explorer

Der Internet Explorer war Microsoft’s Standardbrowser bis Windows 10, trotzdem ist er ebenfalls in Windows 10 inkludiert. Der Internet Explorer Driver ist der einzige Driver der vom Selenium Projekt mit Releases versorgt wird Microsoft considers current. Ältere Releases können weiterhin funktionieren, werden jedoch offiziell nicht weiter unterstützt.

Das Selenium-Projekt stellt die Driver für 32-bit und 64-bit Versionen des Internet Explorer zur Verfügung, es gibt jedoch einige Einschränkungen mit dem Internet Explorer 10 & 11 mit dem 64-bit Driver, jeodch funktioniert die 32-bit Version des Drivers weiterhin. Zu Beachten ist, dass die Einstellungen im Benutzerprofil des aktuell eingeloggten Benutzers gespeichert werden. Weiters sind ein paar zusätzliche Einstellungen notwendig.

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.ie.InternetExplorerDriver;

WebDriver driver = new InternetExplorerDriver();
  
#Simple assignment
from selenium.webdriver import Ie

driver = Ie()
#Or use the context manager
from selenium.webdriver import Ie

with Ie() as driver:
   #your code inside this indent
  
using OpenQA.Selenium;
using OpenQA.Selenium.IE;

IWebDriver driver = new InternetExplorerDriver();
  
require "selenium-webdriver"

driver = Selenium::WebDriver.for :internet_explorer
  
const {Builder} = require('selenium-webdriver');

(async function myFunction() {
   let driver = await new Builder().forBrowser('internet explorer').build();
   //your code inside this block
})();
  
import org.openqa.selenium.WebDriver
import org.openqa.selenium.ie.InternetExplorerDriver

val driver: WebDriver = InternetExplorerDriver()
  

Falls der Internet Explorer Driver nicht im PATH vorhanden ist, kann dieser mittels Programmcode definiert werden:

System.setProperty("webdriver.ie.driver", "C:/path/to/IEDriver.exe");
  
Ie(executable_path='/path/to/IEDriverServer.exe')
  
new InternetExplorerDriver("C:/path/to/IEDriver.exe");
  
Selenium::WebDriver::IE.driver_path = "C:/path/to/IEDriver.exe"
  
const {Builder} = require("selenium-webdriver");
const ie = require('selenium-webdriver/ie');
let service = new ie.ServiceBuilder("/path/to/IEDriverServer.exe");
(async function test() {
    let driver = await new Builder()
                .setIeService(service)
                .forBrowser('internet explorer')
                .build();
})();
  
System.setProperty("webdriver.ie.driver", "C:/path/to/IEDriver.exe")
  

Microsoft bietet auch einen WebDriver für Internet Explorer 11 für Windows 7 & 8.1 an. Dieser wurde seit 2014 nicht mehr aktualisiert und basiert auf einer Entwurfsversion der W3 Spezifikation. Jim Evans hat eine exzellente Beschreibung über die Microsoft Implementierung verfasst.

Opera

Aktuelle Versionen des Operabrowsers basieren auf der Chromiumengine und WebDriver unterstützt fortan die nicht quelloffene Version des Opera Chromium Driver, die der PATH Variable hinzugefügt werden kann, oder als Umgebungsvariable.

Die Instanzierung funktioniert analog zu Firefox und Chromium:

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.opera.OperaDriver;

WebDriver driver = new OperaDriver();
  
#Simple assignment
from selenium.webdriver import Opera

driver = Opera()
#Or use the context manager
from selenium.webdriver import Opera

with Opera() as driver:
   #your code inside this indent
  
using OpenQA.Selenium;
using OpenQA.Selenium.Opera;

IWebDriver driver = new OperaDriver();
  
require "selenium-webdriver"

driver = Selenium::WebDriver.for :opera
  
const {Builder} = require("selenium-webdriver");
const opera = require('selenium-webdriver/opera');
(async function test() {
    let driver = await new Builder()
        .forBrowser('opera')
        .build();
})();
  
import org.openqa.selenium.WebDriver
import org.openqa.selenium.opera.OperaDriver

val driver: WebDriver = OperaDriver()
  

Safari

High Sierra und neuer:

  • Führe den folgenden Befehl im Terminal aus und authorisiere die Ausführung beim ersten Mal mit dem Passwort.
safaridriver --enable

El Capitan and Sierra:

  • Aktiviere das Entwicklermenü in den Safari Einstellungen
  • Prüfe die Allow Remote Automation Option in dem Entwicklermenü
  • Führe folgenden Befehl im Terminal einmalig aus und authorisiere den WebDriver mit dem Paßwort
/usr/bin/safaridriver -p 1337</

Die Driver Session kann dann wie folgt gestartet werden:

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.safari.SafariDriver;

WebDriver driver = new SafariDriver();
  
#Simple assignment
from selenium.webdriver import Safari

driver = Safari()
#Or use the context manager
from selenium.webdriver import Safari

with Safari() as driver:
   #your code inside this indent
  
using OpenQA.Selenium;
using OpenQA.Selenium.Safari;

IWebDriver driver = new SafariDriver();
  
require "selenium-webdriver"

driver = Selenium::WebDriver.for :safari
  
const {Builder} = require('selenium-webdriver');

(async function myFunction() {
   let driver = await new Builder().forBrowser('safari').build();
   //your code inside this block
})();
  
import org.openqa.selenium.WebDriver
import org.openqa.selenium.safari.SafariDriver

val driver: WebDriver = SafariDriver()
  

Wenn eine Automation von Safari auf einem iOS Gerät gewünscht ist dann sollte das Appium Projekt näher betrachtet werden. Während Safari früher auch auf Windows verfügbar war, hat Apple vor längerem den Support dafür eingestellt.

Mock Browser

HtmlUnit

HtmlUnit ist ein Browser für Java Programmierer ohne Oberfläche. Dieser interpretiert HTML Dokumente und stellt Schnittstellen zur Verfügung, die es ermöglichen Seiten aufzurufen, Formulare auszufüllen, Links zu klicken, etc. Er unterstützt auch JavaScript und kann auch mit AJAX Bibliotheken arbeiten indem Chrome, Firefox oder Internet Explorer simuliert wird abhängig welche Konfiguration genutzt wird. Die neue Website ist zu finden unter neuer Link. Der Programmcode wird mit SVN verwaltet.

PhantomJS

PhantomJS ist ein sogenannter headless Browser (ohne grafischer Oberfläche) basierend auf Webkit, eine viel ältere Version wurde von Google Chrome und von Safari genutzt. Auch wenn es früher eine durchaus gute Möglichkeit war sollte PhantomJS nicht mehr genutzt werden. Das Projekt wurde eingestellt und wird nicht mehr gewartet seit dem 5. August 2017. Das Web entwickelt sich ständig weiter, jedoc wird PhantomJS nicht mehr aktualisiert. Die Einstellung erfolgte nachdem Google angekündigt hatte eine Möglichkeit zu schaffen Chrome “headless” zu starten, die Funktionalität ist auch in Mozilla’s Firefox enthalten.

3 - How to upgrade to Selenium 4

Interested in Selenium 4? Check this guide that will help you upgrade to the latest release!

Page being translated from English to German. Do you speak German? Help us to translate it by sending us pull requests!

Upgrading to Selenium 4 should be a painless process if you are using one of the officially supported languages (Ruby, JavaScript, C#, Python, and Java). There might be some cases where a few issues can happen, and this guide will help you to sort them out. We will go through the steps to upgrade your project dependencies and understand the major deprecations and changes the version upgrade brings.

These are the steps we will follow to upgrade to Selenium 4:

  • Preparing our test code
  • Upgrading dependencies
  • Potential errors and deprecation messages

Note: while Selenium 3.x versions were being developed, support for the W3C WebDriver standard was implemented. Both this new protocol and the legacy JSON Wire Protocol were supported. Around version 3.11, Selenium code became compliant with the level W3C 1 specification. The W3C compliant code in the latest version of Selenium 3 will work as expected in Selenium 4.

Preparing our test code

Selenium 4 removes support for the legacy protocol and uses the W3C WebDriver standard by default under the hood. For most things, this implementation will not affect end users. The major exceptions are Capabilities and the Actions class.

Capabilities

If the test capabilities are not structured to be W3C compliant, may cause a session to not be started. Here is the list of W3C WebDriver standard capabilities:

  • browserName
  • browserVersion (replaces version)
  • platformName (replaces platform)
  • acceptInsecureCerts
  • pageLoadStrategy
  • proxy
  • timeouts
  • unhandledPromptBehavior

An up-to-date list of standard capabilities can be found at W3C WebDriver.

Any capability that is not contained in the list above, needs to include a vendor prefix. This applies to browser specific capabilities as well as cloud vendor specific capabilities. For example, if your cloud vendor uses build and name capabilities for your tests, you need to wrap them in a cloud:options block (check with your cloud vendor for the appropriate prefix).

Before

DesiredCapabilities caps = DesiredCapabilities.firefox();
caps.setCapability("platform", "Windows 10");
caps.setCapability("version", "92");
caps.setCapability("build", myTestBuild);
caps.setCapability("name", myTestName);
WebDriver driver = new RemoteWebDriver(new URL(cloudUrl), caps);
caps = {};
caps['browserName'] = 'Firefox';
caps['platform'] = 'Windows 10';
caps['version'] = '92';
caps['build'] = myTestBuild;
caps['name'] = myTestName;
DesiredCapabilities caps = new DesiredCapabilities();
caps.SetCapability("browserName", "firefox");
caps.SetCapability("platform", "Windows 10");
caps.SetCapability("version", "92");
caps.SetCapability("build", myTestBuild);
caps.SetCapability("name", myTestName);
var driver = new RemoteWebDriver(new Uri(CloudURL), capabilities);
caps = Selenium::WebDriver::Remote::Capabilities.firefox
caps[:platform] = 'Windows 10'
caps[:version] = '92'
caps[:build] = my_test_build
caps[:name] = my_test_name
driver = Selenium::WebDriver.for :remote, url: cloud_url, desired_capabilities: caps
caps = {}
caps['browserName'] = 'firefox'
caps['platform'] = 'Windows 10'
caps['version'] = '92'
caps['build'] = my_test_build
caps['name'] = my_test_name
driver = webdriver.Remote(cloud_url, desired_capabilities=caps)

After

FirefoxOptions browserOptions = new FirefoxOptions();
browserOptions.setPlatformName("Windows 10");
browserOptions.setBrowserVersion("92");
Map<String, Object> cloudOptions = new HashMap<>();
cloudOptions.put("build", myTestBuild);
cloudOptions.put("name", myTestName);
browserOptions.setCapability("cloud:options", cloudOptions);
WebDriver driver = new RemoteWebDriver(new URL(cloudUrl), browserOptions);
capabilities = {
  browserName: 'firefox',
  browserVersion: '92',
  platformName: 'Windows 10',
  'cloud:options': {
     build: myTestBuild,
     name: myTestName,
  }
}
var browserOptions = new FirefoxOptions();
browserOptions.PlatformName = "Windows 10";
browserOptions.BrowserVersion = "92";
var cloudOptions = new Dictionary<string, object>();
cloudOptions.Add("build", myTestBuild);
cloudOptions.Add("name", myTestName);
browserOptions.AddAdditionalOption("cloud:options", cloudOptions);
var driver = new RemoteWebDriver(new Uri(CloudURL), options);
options = Selenium::WebDriver::Options.firefox
options.browser_version = 'latest'
options.platform_name = 'Windows 10'
cloud_options = {}
cloud_options[:build] = my_test_build
cloud_options[:name] = my_test_name
options.add_option('cloud:options', cloud_options)
driver = Selenium::WebDriver.for :remote, url: cloud_url, capabilities: options
from selenium.webdriver.firefox.options import Options as FirefoxOptions
options = FirefoxOptions()
options.browser_version = '92'
options.platform_name = 'Windows 10'
cloud_options = {}
cloud_options['build'] = my_test_build
cloud_options['name'] = my_test_name
options.set_capability('cloud:options', cloud_options)
driver = webdriver.Remote(cloud_url, options=options)

Find element(s) utility methods in Java

The utility methods to find elements in the Java bindings (FindsBy interfaces) have been removed as they were meant for internal use only. The following code samples explain this better.

Finding a single element with findElement*

Before

driver.findElementByClassName("className");
driver.findElementByCssSelector(".className");
driver.findElementById("elementId");
driver.findElementByLinkText("linkText");
driver.findElementByName("elementName");
driver.findElementByPartialLinkText("partialText");
driver.findElementByTagName("elementTagName");
driver.findElementByXPath("xPath");

After

driver.findElement(By.className("className"));
driver.findElement(By.cssSelector(".className"));
driver.findElement(By.id("elementId"));
driver.findElement(By.linkText("linkText"));
driver.findElement(By.name("elementName"));
driver.findElement(By.partialLinkText("partialText"));
driver.findElement(By.tagName("elementTagName"));
driver.findElement(By.xpath("xPath"));

Finding a multiple elements with findElements*

Before

driver.findElementsByClassName("className");
driver.findElementsByCssSelector(".className");
driver.findElementsById("elementId");
driver.findElementsByLinkText("linkText");
driver.findElementsByName("elementName");
driver.findElementsByPartialLinkText("partialText");
driver.findElementsByTagName("elementTagName");
driver.findElementsByXPath("xPath");

After

driver.findElements(By.className("className"));
driver.findElements(By.cssSelector(".className"));
driver.findElements(By.id("elementId"));
driver.findElements(By.linkText("linkText"));
driver.findElements(By.name("elementName"));
driver.findElements(By.partialLinkText("partialText"));
driver.findElements(By.tagName("elementTagName"));
driver.findElements(By.xpath("xPath"));

Upgrading dependencies

Check the subsections below to install Selenium 4 and have your project dependencies upgraded.

Java

The process of upgrading Selenium depends on which build tool is being used. We will cover the most common ones for Java, which are Maven and Gradle. The minimum Java version required is still 8.

Maven

Before

<dependencies>
  <!-- more dependencies ... -->
  <dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>3.141.59</version>
  </dependency>
  <!-- more dependencies ... -->
</dependencies>

After

<dependencies>
    <!-- more dependencies ... -->
    <dependency>
        <groupId>org.seleniumhq.selenium</groupId>
        <artifactId>selenium-java</artifactId>
        <version>4.0.0</version>
    </dependency>
    <!-- more dependencies ... -->
</dependencies>

After making the change, you could execute mvn clean compile on the same directory where the pom.xml file is.

Gradle

Before

plugins {
    id 'java'
}
group 'org.example'
version '1.0-SNAPSHOT'
repositories {
    mavenCentral()
}
dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
    implementation group: 'org.seleniumhq.selenium', name: 'selenium-java', version: '3.141.59'
}
test {
    useJUnitPlatform()
}

After

plugins {
    id 'java'
}
group 'org.example'
version '1.0-SNAPSHOT'
repositories {
    mavenCentral()
}
dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
    implementation group: 'org.seleniumhq.selenium', name: 'selenium-java', version: '4.0.0'
}
test {
    useJUnitPlatform()
}

After making the change, you could execute ./gradlew clean build on the same directory where the build.gradle file is.

To check all the Java releases, you can head to MVNRepository.

C#

The place to get updates for Selenium 4 in C# is NuGet. Under the Selenium.WebDriver package you can get the instructions to update to the latest version. Inside of Visual Studio, through the NuGet Package Manager you can execute:

PM> Install-Package Selenium.WebDriver -Version 4.0.0

Python

The most important change to use Python is the minimum required version. Selenium 4 will require a minimum Python 3.7 or higher. More details can be found at the Python Package Index. To upgrade from the command line, you can execute:

pip install selenium==4.0.0

Ruby

The update details for Selenium 4 can be seen at the selenium-webdriver gem in RubyGems. To install the latest version, you can execute:

gem install selenium-webdriver

To add it to your Gemfile:

gem 'selenium-webdriver', '~> 4.0.0'

JavaScript

The selenium-webdriver package can be found at the Node package manager, npmjs. Selenium 4 can be found here. To install it, you could either execute:

npm install selenium-webdriver

Or, update your package.json and run npm install:

{
  "name": "selenium-tests",
  "version": "1.0.0",
  "dependencies": {
    "selenium-webdriver": "^4.0.0"
  }
}

Potential errors and deprecation messages

Here is a set of code examples that will help to overcome the deprecation messages you might encounter after upgrading to Selenium 4.

Java

Waits and Timeout

The parameters received in Timeout have switched from expecting (long time, TimeUnit unit) to expect (Duration duration).

Before

driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
driver.manage().timeouts().setScriptTimeout(2, TimeUnit.MINUTES);
driver.manage().timeouts().pageLoadTimeout(10, TimeUnit.SECONDS);

After

driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
driver.manage().timeouts().scriptTimeout(Duration.ofMinutes(2));
driver.manage().timeouts().pageLoadTimeout(Duration.ofSeconds(10));

Waits are also expecting different parameters now. WebDriverWait is now expecting a Duration instead of a long for timeout in seconds and milliseconds. The withTimeout and pollingEvery utility methods from FluentWait have switched from expecting (long time, TimeUnit unit) to expect (Duration duration).

Before

new WebDriverWait(driver, 3)
.until(ExpectedConditions.elementToBeClickable(By.cssSelector("#id")));

Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)
  .withTimeout(30, TimeUnit.SECONDS)
  .pollingEvery(5, TimeUnit.SECONDS)
  .ignoring(NoSuchElementException.class);

After

new WebDriverWait(driver, Duration.ofSeconds(3))
  .until(ExpectedConditions.elementToBeClickable(By.cssSelector("#id")));

  Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)
  .withTimeout(Duration.ofSeconds(30))
  .pollingEvery(Duration.ofSeconds(5))
  .ignoring(NoSuchElementException.class);

Merging capabilities is no longer changing the calling object

It was possible to merge a different set of capabilities into another set, and it was mutating the calling object. Now, the result of the merge operation needs to be assigned.

Before

MutableCapabilities capabilities = new MutableCapabilities();
capabilities.setCapability("platformVersion", "Windows 10");
FirefoxOptions options = new FirefoxOptions();
options.setHeadless(true);
options.merge(capabilities);

As a result, the options object was getting modified.

After

MutableCapabilities capabilities = new MutableCapabilities();
capabilities.setCapability("platformVersion", "Windows 10");
FirefoxOptions options = new FirefoxOptions();
options.setHeadless(true);
options = options.merge(capabilities);

The result of the merge call needs to be assigned to an object.

Firefox Legacy

Before GeckoDriver was around, the Selenium project had a driver implementation to automate Firefox (version <48). However, this implementation is not needed anymore as it does not work in recent versions of Firefox. To avoid major issues when upgrading to Selenium 4, the setLegacy option will be shown as deprecated. The recommendation is to stop using the old implementation and rely only on GeckoDriver. The following code will show the setLegacy line deprecated after upgrading.

FirefoxOptions options = new FirefoxOptions();
options.setLegacy(true);

BrowserType

The BrowserType interface has been around for a long time, however it is getting deprecated in favour of the new Browser interface.

Before

MutableCapabilities capabilities = new MutableCapabilities();
capabilities.setCapability("browserVersion", "92");
capabilities.setCapability("browserName", BrowserType.FIREFOX);

After

MutableCapabilities capabilities = new MutableCapabilities();
capabilities.setCapability("browserVersion", "92");
capabilities.setCapability("browserName", Browser.FIREFOX);

C#

AddAdditionalCapability is deprecated

Instead of it, AddAdditionalOption is recommended. Here is an example showing this:

Before

var browserOptions = new ChromeOptions();
browserOptions.PlatformName = "Windows 10";
browserOptions.BrowserVersion = "latest";
var cloudOptions = new Dictionary<string, object>();
browserOptions.AddAdditionalCapability("cloud:options", cloudOptions, true);

After

var browserOptions = new ChromeOptions();
browserOptions.PlatformName = "Windows 10";
browserOptions.BrowserVersion = "latest";
var cloudOptions = new Dictionary<string, object>();
browserOptions.AddAdditionalOption("cloud:options", cloudOptions);

Python

executable_path has been deprecated, please pass in a Service object

In Selenium 4, you’ll need to set the driver’s executable_path from a Service object to prevent deprecation warnings. (Or don’t set the path and instead make sure that the driver you need is on the System PATH.)

Before

from selenium import webdriver
options = webdriver.ChromeOptions()
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option("useAutomationExtension", False)
driver = webdriver.Chrome(executable_path=CHROMEDRIVER_PATH, options=options)

After

from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService
options = webdriver.ChromeOptions()
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option("useAutomationExtension", False)
service = ChromeService(executable_path=CHROMEDRIVER_PATH)
driver = webdriver.Chrome(service=service, options=options)

Summary

We went through the major changes to be taken into consideration when upgrading to Selenium 4. Covering the different aspects to cover when test code is prepared for the upgrade, including suggestions on how to prevent potential issues that can show up when using the new version of Selenium. To finalize, we also covered a set of possible issues that you can bump into after upgrading, and we shared potential fixes for those issues.

This was originally posted at https://saucelabs.com/resources/articles/how-to-upgrade-to-selenium-4