This the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

Começando

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

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

Selenium suporta automação de todos os principais navegadores do mercado por meio do uso do WebDriver. WebDriver é uma API e protocolo que define uma interface de linguagem neutra para controlar o comportamento dos navegadores da web. Cada navegador é apoiado por uma implementação WebDriver específica, chamada de driver. O driver é o componente responsável por delegar ao navegador, e lida com a comunicação de e para o Selenium e o navegador.

Essa separação é parte de um esforço consciente para que os fornecedores de navegadores assumam a responsabilidade pela implementação de seus navegadores. Selenium faz uso desses drivers de terceiros sempre que possível, mas também fornece seus próprios drivers mantidos pelo projeto para os casos em que isso não é uma realidade.

A estrutura do Selenium une todas essas peças por meio de uma interface voltada para o usuário que permite aos diferentes back-ends de navegador serem usados de forma transparente, permitindo a automação entre navegadores e plataformas cruzadas.

A configuração do Selenium é bastante diferente da configuração de outras ferramentas comerciais. Para usar Selenium em seu projeto de automação, você precisa instalar as bibliotecas de linguagem para sua linguagem de escolha. Além disso, você precisará dos binários WebDriver para os navegadores que você deseja automatizar e executar testes.

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 - Instalando bibliotecas do Selenium

Setting up the Selenium library for your favourite programming language.

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

Primeiro você precisa instalar as ligações Selenium para seu projeto de automação. O processo de instalação de bibliotecas depende da linguagem que você escolher usar.

Java

A instalação de bibliotecas Selenium para Java pode ser feita usando Maven. Adicione a dependência selenium-java em seu pom.xml:

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

A dependência selenium-java suporta a execução de sua automação com todos os navegadores com suporte Selenium. Se você quiser fazer testes apenas em um navegador específico, você pode adicionar a dependência para esse navegador em seu arquivo pom.xml. Por exemplo, você deve adicionar a seguinte dependência em seu pom.xml arquivo para executar seus testes apenas no Firefox:

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

De maneira semelhante, se você deseja executar testes apenas no Chrome, você deve adicionar a seguinte dependência:

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

Python

A instalação de bibliotecas Selenium para Python pode ser feita usando pip:

pip install selenium

Como alternativa, você pode baixar o arquivo de origem do PyPI (selenium-x.x.x.tar.gz) e instale-o usando setup.py:

python setup.py install

C#

A instalação de bibliotecas Selenium para C# pode ser feita usando NuGet:

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

Ruby

A instalação de bibliotecas Selenium para Ruby pode ser feita usando gem:

gem install selenium-webdriver

JavaScript

A instalação de bibliotecas Selenium para JavaScript pode ser feita usando npm:

npm install selenium-webdriver

Kotlin

Devido à ausência de vínculos de linguagem nativo para Kotlin, você deve usar vínculos Java, por exemplo, com Maven Java

2 - Installing browser drivers

Setting up your browser ready to be automated.

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

Por meio do WebDriver, o Selenium oferece suporte a todos os principais navegadores do mercado como Chrom(ium), Firefox, Internet Explorer, Edge, Opera e Safari. Sempre que possível, o WebDriver dirige o navegador usando o suporte integrado do navegador para automação, embora nem todos os navegadores tenham suporte oficial para controle remoto.

O objetivo do WebDriver é emular a interação de um usuário real com o navegador o mais próximo possível. Isso é possível em vários níveis em diferentes navegadores.

Mesmo que todos os drivers compartilhem uma única interface voltada para o usuário para controlar o navegador, eles têm maneiras ligeiramente diferentes de configurar sessões do navegador. Uma vez que muitas das implementações de driver são fornecidas por terceiros, elas não estão incluídas na distribuição padrão do Selenium.

Instanciação do driver, gerenciamento de perfil e várias configurações específicas do navegador são exemplos de parâmetros que têm requisitos diferentes dependendo do navegador. Esta seção explica os requisitos básicos para começar com os diferentes navegadores.

Adicionando executáveis ao seu PATH

A maioria dos drivers requerem um executável extra para o Selenium se comunicar com o navegador. Você pode especificar manualmente onde o executável reside antes de iniciar o WebDriver, mas isso pode tornar seus testes menos portáveis já que os executáveis precisarão estar no mesmo lugar em todas as máquinas, ou inclua o executável em seu repositório de código de teste.

Ao adicionar uma pasta contendo os binários do WebDriver aos do seu path, o Selenium será capaz de localizar os binários adicionais sem exigir seu código de teste para localizar exatamente o driver.

  • Crie um diretório para colocar os executáveis, como C:\WebDriver\bin ou /opt/WebDriver/bin
  • Adicione o diretório ao seu PATH:
    • No Windows - Abra um prompt de comando como administrador e execute o seguinte comando para adicionar permanentemente o diretório ao seu PATH para todos os usuários em sua máquina:
setx PATH "%PATH%;C:\WebDriver\bin"
  • Usuários do Bash no macOS e Linux - Em um terminal:
export PATH=$PATH:/opt/WebDriver/bin >> ~/.profile
  • Agora você está pronto para testar suas alterações. Feche todos os prompts de comando abertos e abra um novo. Digite o nome de um dos binários na pasta que você criou na etapa anterior, por exemplo:

    chromedriver
    
  • Se o seu PATH estiver configurado corretamente, você verá alguma saída relacionada à inicialização do driver:

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

Você pode recuperar o controle do seu prompt de comando pressionando Ctrl+C

Quick reference

NavegadorOS SuportadoMantido porDownloadProblemas
Chromium/ChromeWindows/macOS/LinuxGoogleDownloadsProblemas
FirefoxWindows/macOS/LinuxMozillaDownloadsProblemas
EdgeWindows 10MicrosoftDownloadsProblemas
Internet ExplorerWindowsSelenium ProjectDownloadsProblemas
SafarimacOS El Capitan ou mais novoAppleEmbutidoProblemas
OperaWindows/macOS/LinuxOperaDownloadsProblemas

Chromium/Chrome

Para conduzir o Chrome ou Chromium, você deve fazer o download do chromedriver e colocá-lo em uma pasta que está no PATH do seu sistema.

No Linux ou macOS, isso significa modificar a variável de ambiente PATH. Você pode ver quais diretórios, separados por dois pontos, constituem o PATH do seu sistema executando o seguinte comando:

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

Para incluir o chromedriver no PATH, se ainda não estiver, certifique-se de incluir o diretório pai do binário chromedriver. A linha a seguir irá definir a variável de ambiente PATH com seu conteúdo atual, mais um caminho adicional adicionado após os dois pontos:

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

Quando o chromedriver estiver disponível em seu PATH, você deve ser capaz de executar o executável chromedriver de qualquer diretório.

Para instanciar uma sessão do Chrome/Chromium, você pode fazer o seguinte:

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

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

driver = Chrome()

#Or use the context manager
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()
  

Remember that you have to set the path to the chromedriver executable. This is possible using the following line:

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

O chromedriver é implementado como um servidor remoto WebDriver que instrui o navegador sobre o que fazer ao expor o interface de proxy de automação interna.

Firefox

Começando com Selenium 3, a Mozilla assumiu a implementação do Driver do Firefox, com geckodriver. O novo driver para Firefox é chamado geckodriver e funciona com Firefox 48 e mais recentes. Como o Firefox WebDriver está em desenvolvimento, quanto mais nova for a versão do Firefox, melhor será o suporte.

Como geckodriver é a nova forma padrão de iniciar o Firefox, você pode instanciar o Firefox da mesma forma que o 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()
  

Se você preferir não definir a localização do geckodriver usando PATH, defina a localização do binário geckodriver programaticamente:

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

Também é possível definir a propriedade em tempo de execução:

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

Atualmente é possível reverter para o driver mais antigo, mais completo do Firefox, instalando o Firefox 47.0.1 ou 45 ESR e especificando o recurso desejado de marionette como false. Versões posteriores do Firefox não são mais compatíveis.

Edge

Edge é o navegador mais recente da Microsoft, incluído no Windows 10 e Server 2016. As atualizações do Edge são agrupadas com as principais atualizações do Windows, então você precisará baixar um binário que corresponda ao número da compilação da sua compilação do Windows atualmente instalada. O site do Edge Developer contém links para todos os binários disponíveis. Bugs na implementação do EdgeDriver podem ser levantados com Microsoft. Se você gostaria de executar testes no Edge, mas não está executando o Windows 10, a Microsoft oferece VMs gratuitas para testadores no site do Edge Developer.

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

Se o driver Edge não estiver presente em seu PATH, você pode definir o PATH usando a seguinte linha:

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

O Internet Explorer era o navegador padrão da Microsoft até o Windows 10, embora ainda esteja incluído no Windows 10. O driver do Internet Explorer é o único driver que o projeto Selenium visa apoiar os mesmos lançamentos que a Microsoft considera atual. Versões mais antigas podem funcionar, mas não serão suportadas.

Embora o projeto Selenium forneça binários tanto para 32 bits quanto para 64 bits, existem algumas limitações com o Internet Explorer 10 e 11 com o driver de 64 bits, mas usando o de 32 bits o driver continua a funcionar bem. Deve-se notar que, como as preferências do Internet Explorer são salvas na conta do usuário conectado, alguma configuração adicional é necessária.

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

Se o driver do Internet Explorer não estiver presente em seu PATH, você pode definir o PATH usando a seguinte linha:

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

A Microsoft também oferece um binário WebDriver para Internet Explorer 11 no Windows 7 e 8.1. Não é atualizado desde 2014 e é baseado em uma versão preliminar da Especificação W3. Jim Evans tem um excelente artigo sobre a implementação da Microsoft.

Opera

As versões atuais do Opera são construídas com base no mecanismo Chromium, e WebDriver agora é compatível com o código fechado Driver Opera Chromium, que pode ser adicionado ao seu PATH ou como um propriedade do sistema.

Instanciar uma sessão de driver é semelhante a Firefox e 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 e posterior:

  • Execute o seguinte comando do terminal na primeira vez e digite sua senha no prompt para autorizar o WebDriver
safaridriver --enable

El Capitan e Sierra:

  • Ative o menu Desenvolvedor nas preferências do Safari
  • Marque a opção Permitir automação remota com o menu Desenvolver
  • Execute o seguinte comando do terminal na primeira vez e digite sua senha no prompt para autorizar WebDriver
/usr/bin/safaridriver -p 1337</

Você pode então iniciar uma sessão de driver usando:

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

Aqueles que procuram automatizar o Safari no iOS devem olhar para o Projeto Appium. Enquanto o Safari era anteriormente disponível para Windows, a Apple há muito abandonou o suporte, tornando-o uma má escolha de plataforma de teste.

HtmlUnit

HtmlUnit é um “navegador sem interface gráfica para programas Java”. Ele modela documentos HTML e fornece uma API que permite invocar páginas, preencher formulários, clicar links, etc. Possui suporte a JavaScript e é capaz de trabalhar com bibliotecas AJAX, simulando Chrome, Firefox ou Internet Explorer dependendo da configuração usada. Foi movido para um novo local. A fonte é mantida em svn.

PhantomJS

PhantomJS é um navegador sem cabeçalho baseado em Webkit, embora seja uma versão muito mais antiga do que o usado pelo Google Chrome ou Safari. Embora historicamente seja uma popular escolha, agora seria sábio evitar o PhantomJS. O projeto está sem manutenção desde 5 de agosto de 2017, portanto, embora a web continue a mudar, o PhantomJS não será atualizado. Isso foi depois que o Google anunciou a capacidade de executar o Chrome sem cabeçalho, algo também agora oferecido pelo Firefox da Mozilla.

3 - Como atualizar para Selenium 4

Interested in Selenium 4? Check this guide that will help you upgrade to the latest release! Interessado no Selenium 4? Veja este guia para realizar o upgrade para a ultima versão!

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

Esta página está sendo traduzido do Inglês para o Português. Você fala Inglês? Nos ajude a traduzir esta pagina enviando pull requests!

Atualizar para o Selenium 4 deve ser um processo sem dificuldades se você estiver usando uma das linguagens oficialmente suportadas (Ruby, JavaScript, C#, Python, and Java). Pode haver alguns casos em que alguns problemas podem acontecer, este guia irá ajudar você a resolvê-los. Vamos passar as etapas para atualizar as dependências do seu projeto e entender as depreciações e também as mudanças trazidas pela versão atualizada.

Estas são as etapas que seguiremos para atualizar para o Selenium 4:

  • Preparando nosso código de teste
  • Atualizando as dependências
  • Possíveis erros e mensagens de suspensão de uso

Nota: enquanto as versões do Selenium 3.x estavam sendo desenvolvidas, foi implementado o suporte padrão para W3C WebDriver. Este novo protocolo e o legado JSON Wire Protocol foram suportados. Através da versão 3.11, o código do Selenium passou a ser compátivel com o nível 1 da especificação W3C. A compatibilidade do código W3C na ultima versão do Selenium 3 irá funcionar como esperado na versão 4.

Preparando nosso código de teste

Selenium 4 remove suporte para protocolos legados e usa o W3C Webdriver por padrão. Para a maioria das coisas, essa implementação não irá afetar usuários finais. As maiores exeções são Capabilities e a classe Actions.

Recursos

Se os recursos de teste não forem estruturados para serem compatíveis com W3C, pode fazer com que uma sessão não seja iniciada. Aqui está a lista de recursos padrão do W3C WebDriver:

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

Uma lista atualizada de recursos padrão pode ser encontrada aqui: W3C WebDriver.

Qualquer recurso que não esteja incluido na lista acima, precisa ser incluido um prefixo de fornecedor. Isso se aplica aos recursos específicos do navegador, bem como aos recursos específicos do fornecedor da nuvem. Por exemplo, se o seu fornecedor de nuvem usa os recursos build e name para seus testes, você precisa envolvê-los em um bloco cloud: options (verifique com seu fornecedor de nuvem o prefixo apropriado).

Antes

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)

Depois

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)

Utilitário para encontrar elemento (s) no Java

O utilitário para localizar elementos no Java (interfaces FindsBy) foram removidos visto que se destinavam apenas a uso interno. Os exemplos de código a seguir explicam isso melhor.

Encontrando um único elemento com 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"));

Encontrando multiplos elementos com 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"));

Atualizando as dependências

Verifique as subseções abaixo para isntalar o Selenium 4 e atualizar as dependências do seu projeto

Java

O processo de atualização do Selenium depende de qual ferramenta de compilação está sendo usada. Vamos mostrar as mais comuns para Java, como Maven e Gradle. A versão minínma do Java ainda é 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()
}

Após realizar a mudança, você pode executar ./gradlew clean build no mesmo diretório em o arquivo build.gradleestá.

Para verifica todas as versões do Java, você pode ir até MVNRepository.

C#

O local para obter atualizações para Selenium 4 em C# é NuGet Dentro do pacaote Selenium.WebDriver você pode seguir as instruções para atualizar para ultima versão. Dentro do Visual Studio, através do NuGet Package Manager você pode executar:

PM> Install-Package Selenium.WebDriver -Version 4.0.0

Python

A mudança mais importante para usar o Python é a versão minima requerida. Para Selenium 4 a versão miníma requerida será Python3.7 ou superior. Mais detalhes podem ser encontrados aqui:Python Package Index. Para ataulizar através da linha de comando, você pode executar:

pip install selenium==4.0.0

Ruby

Detalhes para atualizar para o Selenium 4 podem ser vistos aqui: selenium-webdriver gem in RubyGems Para instalar a ultima versão, você pode executar:

gem install selenium-webdriver

Para adicioná-lo ao seu Gemfile:

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

JavaScript

O pacote selenium-webdriver pode ser encontrado pelo Node package manager, npmjs. Selenium 4 pode ser encontrado aqui. Para instalar, você pode executar:

npm install selenium-webdriver

Ou, atualize o seu package.json e execute 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