O Projeto Selenium de Automação de Navegadores

• 1: Resumo
• 1.1: Entendendo os componentes
• 1.2: Detalhes
• 2: WebDriver
• 2.1: Começando
• 2.1.1: Instalando bibliotecas do Selenium
• 2.1.2: Programe o seu primeiro script Selenium
• 2.1.3: Organizando e executando o código Selenium
• 2.2: Driver Sessions
• 2.2.1: Opções do navegador
• 2.2.2: HTTP Client Configuration
• 2.2.3: Driver Service Class
• 2.2.4: Remote WebDriver
• 2.3: Navegadores suportados
• 2.3.1: Funcionalidade específica do Chrome
• 2.3.2: Funcionalidade específica do Edge
• 2.3.3: Funcionalidade específica do Firefox
• 2.3.4: Funcionalidade específica do IE
• 2.3.5: Funcionalidade específica do Safari
• 2.4: Esperas
• 2.5: Elemento Web
• 2.5.1: File Upload
• 2.5.2: Encontrando Elementos Web
• 2.5.3: Interacting with web elements
• 2.5.4: Information about web elements
• 2.5.5: Localizando elementos
• 2.6: Browser interactions
• 2.6.1: Browser navigation
• 2.6.2: Alertas, prompts e confirmações JavaScript
• 2.6.3: Trabalhando com cookies
• 2.6.4: Working with IFrames and frames
• 2.6.5: Working with windows and tabs
• 2.6.6: Virtual Authenticator
• 2.7: Ações API
• 2.7.1: Ações de Teclado
• 2.7.2: Ações do Mouse
• 2.7.3: Ações de Caneta
• 2.7.4: Ações de Roda de Rolagem
• 2.8: BiDirectional Functionality
• 2.8.1: Chrome DevTools
• 2.8.1.1: Chrome DevTools Protocol Endpoint
• 2.8.1.2: Chrome DevTools Protocol API
• 2.8.1.3: Chrome Devtools Protocol with BiDi API
• 2.8.2: BiDirectional API (W3C compliant)
• 2.8.2.1: Browsing Context
• 2.8.2.2: Browsing Context
• 2.8.2.3: Network
• 2.8.2.4: Script
• 2.8.2.5: BiDirectional API (W3C compliant)
• 2.9: Recursos de suporte
• 2.9.1: Command Listeners
• 2.9.2: Trabalhando com cores
• 2.9.3: ThreadGuard
• 2.9.4: Trabalhando com elementos select
• 2.9.5:
• 2.10: Troubleshooting Assistance
• 2.10.1: Understanding Common Errors
• 2.10.1.1: Unable to Locate Driver Error
• 2.10.2: Logging Selenium commands
• 2.10.3: Como atualizar para Selenium 4
• 3: Selenium Manager (Beta)
• 4: Grid
• 4.1: Configurando a sua
• 4.2: Quando usar a Grid
• 4.3: Componentes
• 4.4: Configurando componentes
• 4.4.1: Ajuda de configuração
• 4.4.2: Opções CLI
• 4.4.3: Toml Options
• 4.5: Arquitectura da Grid
• 4.6: Características avançadas
• 4.6.1: Observabilidade
• 4.6.2: Suporte a buscas em GraphQL
• 4.6.3: Rotas da Grid
• 4.6.4: Personalizando um Nó
• 4.6.5: External datastore
• 5: Servidor de drivers do IE
• 5.1: Internet Explorer Driver Internals
• 6: Selenium IDE
• 7: Diretrizes e recomendações
• 7.1: Design patterns and development strategies
• 7.2: Sobre automação de testes
• 7.3: Tipos de teste
• 7.4: Diretrizes e recomendações
• 7.4.1: Modelos de objetos de página
• 7.4.2: Linguagem específica de domínio (DSL)
• 7.4.3: Gerando estado da aplicação
• 7.4.4: Simulação de serviços externos
• 7.4.5: Relatórios melhorados
• 7.4.6: Evite compartilhamento de estado
• 7.4.7: Tips on working with locators
• 7.4.8: Independência de Testes
• 7.4.9: Considere usar uma API fluente
• 7.4.10: Navegador novo por teste
• 7.5: Piores práticas
• 7.5.1: Captchas
• 7.5.2: Downloads de arquivo
• 7.5.3: Códigos de respostas HTTP
• 7.5.4: Login via Gmail, email e Facebook
• 7.5.5: Dependência entre testes
• 7.5.6: Teste de performance/desempenho
• 7.5.7: Navegação por links
• 7.5.8: Autenticação de Dois Fatores (2FA)
• 8: Legado
• 8.1: Selenium RC (Selenium 1)
• 8.2: Selenium 2
• 8.2.1: Migrando do RC para WebDriver
• 8.2.2: Servidor do WebDriver remoto
• 8.3: Selenium 3
• 8.3.1: Grid 3
• 8.3.2: Configurando a sua
• 8.3.3: Componentes
• 8.4: Selenium IDE Legado
• 8.4.1: HTML runner
• 9: Sobre esta documentação
• 9.1: Direitos autorais e atribuições
• 9.2: Contribuindo com o Site e Documentação do Selenium
• 9.3: Style guide for Selenium documentation

package dev.selenium.hello;

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

public class HelloSelenium {
    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();

        driver.get("https://selenium.dev");

        driver.quit();
    }
}

from selenium import webdriver


driver = webdriver.Chrome()

driver.get("http://selenium.dev")

driver.quit()

using OpenQA.Selenium.Chrome;

namespace SeleniumDocs.Hello;

public static class HelloSelenium
{
    public static void Main()
    {
        var driver = new ChromeDriver();
            
        driver.Navigate().GoToUrl("https://selenium.dev");
            
        driver.Quit();
    }
}

require 'selenium-webdriver'

driver = Selenium::WebDriver.for :chrome

driver.get 'https://selenium.dev'

driver.quit

const {Builder, Browser} = require('selenium-webdriver');

(async function helloSelenium() {
  let driver = await new Builder().forBrowser(Browser.CHROME).build();

  await driver.get('https://selenium.dev');

  await driver.quit();
})();

package dev.selenium.hello

import org.openqa.selenium.chrome.ChromeDriver

fun main() {
    val driver = ChromeDriver()

    driver.get("https://selenium.dev")

    driver.quit()
}

1 - Resumo

Selenium não é só uma ferramenta ou API, mas sim uma composição de várias ferramentas.

WebDriver

Se você está começando com automação de testes de um site de desktop ou site para celular, então vai usar as APIs WebDriver. O WebDriver usa APIs de automação de navegador disponibilizadas por fornecedores de navegador para o controlar e executar testes. É como se um usuário real o estivesse operando. Como o WebDriver não exige que sua API seja compilada com o código do aplicativo, não é intrusivo. Portanto, você está testando o mesmo aplicativo que você envia aos ambientes de produção.

IDE

IDE (Ambiente de Desenvolvimento Integrado, em português) é a ferramenta que você usa para desenvolver seus casos de teste Selenium. É uma extensão para Chrome e Firefox fácil de usar e geralmente é a maneira mais eficiente de desenvolver casos de teste. Ela registra as ações dos usuários no navegador para você, usando comandos Selenium existentes, com parâmetros definidos pelo contexto daquele elemento. Isso não é apenas uma economia de tempo, mas também uma maneira excelente de aprender a sintaxe de script do Selenium.

Grid

Selenium Grid permite que você execute casos de teste em diferentes máquinas em diferentes plataformas. O controle para acionar os casos de teste está na extremidade local, e quando os casos de teste são acionados, eles são automaticamente executados pela extremidade remota.

Após o desenvolvimento dos testes WebDriver, você pode enfrentar a necessidade de executar seus testes em vários navegadores e combinações de sistemas operacionais. É aqui que o Grid entra em cena.

1.1 - Entendendo os componentes

Construir um conjunto de testes usando WebDriver exigirá que você entenda e use efetivamente uma série de componentes diferentes. Como com tudo em software, pessoas diferentes usam termos diferentes para a mesma ideia. Abaixo está uma análise de como os termos são usados nesta descrição.

Terminologia

• API: interface de programação de aplicativo. Este é o conjunto de “comandos” que você usa para manipular o WebDriver.
• Biblioteca: um módulo de código que contém as APIs e o código necessário para implementá-los. As bibliotecas são específicas para cada linguagem, por exemplo arquivos .jar para Java, arquivos .dll para .NET, etc.
• Driver: responsável por controlar o navegador atual. A maioria dos drivers são criados pelos próprios fornecedores de navegadores. Os drivers são geralmente módulos executáveis ​​que são executados no sistema com o próprio navegador, não no sistema que está executando o conjunto de testes. (Embora esses possam ser mesmo sistema.) NOTA: Algumas pessoas se referem aos drivers como proxies.
• Framework: uma biblioteca adicional usada como suporte para suítes do WebDriver.
• Essas estruturas podem ser estruturas de teste, como JUnit ou NUnit. Eles também podem ser estruturas que suportam recursos de linguagem natural, como como Cucumber ou Robotium. Frameworks também podem ser escritos e usados ​​para coisas como manipulação ou configuração do sistema em teste, criação de dados, oráculos de teste, etc.

As partes e peças

No mínimo, o WebDriver se comunica com um navegador por meio de um driver. Comunicação é bidirecional: o WebDriver passa comandos para o navegador por meio do driver e recebe informações de volta pela mesma rota.

O driver é específico para o navegador, como ChromeDriver para Google Chrome / Chromium, GeckoDriver para Mozilla Firefox, etc. O driver é executado no mesmo sistema do navegador. Este pode, ou não ser, o mesmo sistema onde os próprios testes estão sendo executados.

Este exemplo simples acima é comunicação direta. Comunicação para o navegador também pode ser comunicação remota através do servidor Selenium ou RemoteWebDriver. RemoteWebDriver roda no mesmo sistema que o driver e o navegador.

A comunicação remota também pode ocorrer usando Selenium Server ou Selenium Grid, que, por sua vez, fala com o driver no sistema host

Onde frameworks se encaixam

O WebDriver tem um trabalho e apenas um trabalho: comunicar-se com o navegador por meio de qualquer um dos métodos acima. O WebDriver não sabe nada sobre testes: ele não sabe como comparar coisas, afirmar passa ou falha, e certamente não sabe uma coisa sobre relatórios ou gramática Dado / Quando / Então.

É aqui que vários frameworks entram em cena. No mínimo, você precisará de um framework de teste que corresponde às linguagens, por exemplo, NUnit para .NET, JUnit para Java, RSpec para Ruby, etc.

O framework de teste é responsável por rodar e executar seu WebDriver e etapas relacionadas em seus testes. Como tal, você pode pensar nele parecendo a imagem seguinte.

Frameworks/ferramentas de linguagem natural, como Cucumber, podem existir como parte desse framework de teste na figura acima, ou eles podem envolver o framework de teste inteiramente em sua própria implementação.

1.2 - Detalhes

Selenium controla navegadores

Selenium é muitas coisas mas, em sua essência, é um conjunto de ferramentas para automação de navegador da web que usa as melhores técnicas disponíveis para controlar remotamente as instâncias do navegador e emular a interação do usuário com o navegador.

Ele permite que os usuários simulem atividades comuns realizadas por usuários finais; inserir texto em campos, selecionando valores suspensos e caixas de seleção, e clicar em links em documentos. Ele também fornece muitos outros controles, como o movimento do mouse, execução arbitrária de JavaScript e muito mais.

Embora seja usado principalmente para testes de front-end de sites, Selenium é basicamente uma biblioteca de agente de usuário de navegador. As interfaces são onipresentes em seus aplicativos, o que incentiva a composição com outras bibliotecas para atender a sua finalidade.

Uma interface para tudo

Um dos princípios norteadores do projeto é oferecer suporte a uma interface comum para todas as tecnologias de navegador (principais). Os navegadores da web são aplicativos incrivelmente complexos e altamente projetados, realizando suas operações de maneiras completamente diferentes mas que frequentemente têm a mesma aparência ao fazê-lo. Mesmo que o texto seja renderizado com as mesmas fontes, as imagens sejam exibidas no mesmo lugar e os links levem você ao mesmo destino. O que está acontecendo por baixo é tão diferente quanto noite e dia. Selenium “abstrai” essas diferenças, esconde seus detalhes e complexidades da pessoa que está escrevendo o código. Isso permite que você escreva várias linhas de código para realizar um fluxo de trabalho complicado, mas essas mesmas linhas serão executadas no Firefox, Internet Explorer, Chrome e todos os outros navegadores compatíveis.

Ferramentas e suporte

A abordagem de design minimalista do Selenium lhe dá a versatilidade para ser incluído como um componente em aplicações maiores. A infraestrutura circundante fornecida sob o Selenium dá a você as ferramentas para montar sua Grid de navegadores para que os testes possam ser executados em diferentes navegadores e sistemas operacionais em uma variedade de máquinas.

Imagine um banco de computadores em sua sala de servidores ou data center todos abrindo navegadores ao mesmo tempo acessando links, formulários, e tabelas — testando seu aplicativo 24 horas por dia. Por meio da interface de programação simples fornecido para os idiomas mais comuns, esses testes serão executados incansavelmente em paralelo, reportando de volta para você quando ocorrerem erros.

É o objetivo de ajudar a tornar isso uma realidade para você, fornecendo aos usuários ferramentas e documentação não apenas para controlar os navegadores mas para tornar mais fácil dimensionar e implantar essas grades.

Quem usa Selenium

Muitas das empresas mais importantes do mundo adotaram o Selenium para seus testes baseados em navegador, frequentemente substituindo esforços de anos envolvendo outras ferramentas proprietárias. À medida que sua popularidade cresceu, seus requisitos e desafios se multiplicaram.

Conforme a web se torna mais complicada e novas tecnologias são adicionadas aos sites, é a missão deste projeto acompanhá-los sempre que possível. Sendo um projeto de código aberto, este apoio é fornecido por meio da generosa doação de tempo de muitos voluntários, cada um deles tem um “trabalho diurno”.

Outra missão do projeto é incentivar mais voluntários para participar deste esforço, e construir uma comunidade forte para que o projeto possa continuar a acompanhar as tecnologias emergentes e permanecer uma plataforma dominante para automação de teste funcional.

2 - WebDriver

O WebDriver manipula um navegador nativamente, como um usuário faria, seja localmente ou em uma máquina remota usando o servidor Selenium, marca um salto em termos de automação do navegador.

Selenium WebDriver refere-se a ambas as ligações de linguagem e as implementações do código de controle do navegador individual. Isso é comumente referido como apenas WebDriver.

Selenium WebDriver é uma recomendação W3C

• WebDriver é projetado como uma interface de programação simples e mais concisa.

• WebDriver é uma API compacta orientada a objetos.

• Ele manipula o navegador de forma eficaz.

2.1 - Começando

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.

Selenium setup is quite different from the setup of other commercial tools. Before you can start writing Selenium code, you have to install the language bindings libraries for your language of choice, the browser you want to use, and the driver for that browser.

Follow the links below to get up and going with Selenium WebDriver.

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

Once you get things working, if you want to scale up your tests, check out the Selenium Grid.

2.1.1 - Instalando bibliotecas do Selenium

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

Requisitos por linguagem

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    <dependencies>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>${selenium.version}</version>

    testImplementation 'org.seleniumhq.selenium:selenium-java:4.20.0'
    testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.10.2'

pip install selenium

python setup.py install

selenium==4.20.0

Install-Package Selenium.WebDriver

dotnet add package Selenium.WebDriver

      <PackageReference Include="Selenium.WebDriver" Version="4.20.0" />

<configuration>
  <packageSources>
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
    <add key="nuget.org" value="https://www.nuget.org/api/v2/" />   
  </packageSources>
...

gem install selenium-webdriver

gem 'selenium-devtools', '= 0.124.0'

npm install selenium-webdriver

        "mocha": "10.4.0"

Próximo passo

Programando o seu primeiro script Selenium

2.1.2 - Programe o seu primeiro script Selenium

Assim que você tiver o Selenium instalado, você estará pronto para programar códigos Selenium.

Oito Componentes Básicos

Tudo que o Selenium faz é enviar comandos ao navegador de internet para fazer algo ou solicitar informações dele. A maior parte do que você irá fazer com o Selenium é uma combinação desses comandos básicos.

Click on the link to “View full example on GitHub” to see the code in context.

1. Iniciando uma sessão

Para ter mais detalhes sobre como iniciar uma sessão, leia nossa documentação em driver sessions

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

        WebDriver driver = new ChromeDriver();

driver = webdriver.Chrome()

        IWebDriver driver = new ChromeDriver();

driver = Selenium::WebDriver.for :chrome

    driver = await new Builder().forBrowser(Browser.CHROME).build();

        driver = ChromeDriver()

2. Agindo no navegador de internet

Nesse exemplo estamos navegando para uma página web.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

        driver.get("https://www.selenium.dev/selenium/web/web-form.html");

driver.get("https://www.selenium.dev/selenium/web/web-form.html")

        driver.Navigate().GoToUrl("https://www.selenium.dev/selenium/web/web-form.html");

driver.get('https://www.selenium.dev/selenium/web/web-form.html')

    await driver.get('https://www.selenium.dev/selenium/web/web-form.html');

        driver.get("https://www.selenium.dev/selenium/web/web-form.html")

3. Solicitando informação do navegador de internet

Existem diversos tipos de informação sobre o navegador de internet que você pode solicitar, incluindo window handles, tamanho / posição do navegador, cookies, alertas e etc.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

        driver.getTitle();

title = driver.title

        var title = driver.Title;

driver.title

    let title = await driver.getTitle();

        val title = driver.title

4. Estabelecendo uma Estratégia de Espera

Sincronizar o código ao estado atual do navegador é um dos maiores desafios quando se trabalha com o Selenium, fazer isso de maneira bem feita é um tópico avançado.

Essencialmente, você quer ter certeza absoluta de que o elemento está na página antes de tentar localizá-lo e o elemento está em um estado interativo antes de você tentar interagir com ele.

Uma espera implícita raramente é a melhor solução, mas é a mais fácil de demonstrar aqui, então vamos usá-la como um substituto.

Leia mais sobre Estratégias de espera.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

        driver.manage().timeouts().implicitlyWait(Duration.ofMillis(500));

driver.implicitly_wait(0.5)

        driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromMilliseconds(500);

driver.manage.timeouts.implicit_wait = 500

    await driver.manage().setTimeouts({implicit: 500});

        driver.manage().timeouts().implicitlyWait(Duration.ofMillis(500))

5. Encontrando um elemento

A maioria dos comandos na maior parte das sessões do Selenium são relacionados a elementos e você não pode interagir com um sem o primeiro encontrando um elemento

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

        WebElement textBox = driver.findElement(By.name("my-text"));
        WebElement submitButton = driver.findElement(By.cssSelector("button"));

text_box = driver.find_element(by=By.NAME, value="my-text")
submit_button = driver.find_element(by=By.CSS_SELECTOR, value="button")

        var textBox = driver.FindElement(By.Name("my-text"));
        var submitButton = driver.FindElement(By.TagName("button"));

text_box = driver.find_element(name: 'my-text')
submit_button = driver.find_element(tag_name: 'button')

    let textBox = await driver.findElement(By.name('my-text'));
    let submitButton = await driver.findElement(By.css('button'));

        var textBox = driver.findElement(By.name("my-text"))
        val submitButton = driver.findElement(By.cssSelector("button"))

6. Agindo no elemento

Há apenas um punhado de ações a serem executadas em um elemento, mas você irá usá-las com frequência.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

        textBox.sendKeys("Selenium");
        submitButton.click();

text_box.send_keys("Selenium")
submit_button.click()

        textBox.SendKeys("Selenium");
        submitButton.Click();

text_box.send_keys('Selenium')
submit_button.click

    await textBox.sendKeys('Selenium');
    await submitButton.click();

        textBox.sendKeys("Selenium")
        submitButton.click()

7. Solicitando informações do elemento

Elementos podem guardar muitas informações que podem ser solicitadas.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

        message.getText();

text = message.text

        var value = message.Text;

message.text

    let value = await message.getText();

        val value = message.getText()

8. Encerrando a sessão

Isso encerra o processo do driver, que por padrão também fecha o navegador. Nenhum outro comando pode ser enviado para esta instância do driver.

See Quitting Sessions.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

        driver.quit();

driver.quit()

        driver.Quit();

driver.quit

    await driver.quit();

        driver.quit()

Running Selenium File

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

ruby example_script.rb

node example_script.spec.js

Próximos Passos

Most Selenium users execute many sessions and need to organize them to minimize duplication and keep the code more maintainable. Read on to learn about how to put this code into context for your use case with Using Selenium.

2.1.3 - Organizando e executando o código Selenium

Se quiser executar mais do que um punhado de scripts pontuais, precisa de ser capaz de organizar e trabalhar com seu código. Esta página deve dar a você ideias de como fazer coisas produtivas com seu código Selenium.

Usos comuns

A maioria das pessoas usa o Selenium para executar testes automatizados para aplicações web, mas o Selenium suporta qualquer caso de uso de automação de navegador.

Tarefas Repetitivas

Talvez seja necessário fazer login em um site e baixar algo ou enviar um formulário. Você pode criar um script Selenium para ser executado com um serviço em horários pré-definidos.

Web Scrapping

Está a tentar recolher dados de um site que não tem uma API? O Selenium permitirá que você faça isso, mas certifique-se de estar familiarizado com os termos de serviço do site termos de serviço do site, pois alguns sites não permitem isso e outros até bloqueiam o Selenium.

Testes

Executar o Selenium para testes requer fazer asserções sobre as ações tomadas pelo Selenium. Então uma boa biblioteca de asserções é necessária. Características adicionais para prover estrutura para testes requerem o uso de [Test Runner] (#test-runners).

IDEs

Independentemente de como você usa o código do Selenium, não será muito eficaz escrevendo ou executando-o sem um bom ambiente de desenvolvimento integrado. Aqui estão algumas opções comuns…

• Eclipse
• IntelliJ IDEA
• PyCharm
• RubyMine
• Rider
• WebStorm
• VS Code

Executador de teste

Mesmo que não esteja a usar o Selenium para testes, se tiver casos de uso avançado, pode fazer sentido usar um executor de testes para organizar melhor seu código. Ser capaz de usar hooks antes/depois e executar coisas em grupos ou em paralelo pode ser muito útil.

Escolhendo

Há muitos executores de teste diferentes disponíveis.

Todos os exemplos de código nesta documentação podem ser encontrados em (ou estão sendo movidos para) nossos diretórios que usam test runners e são executados a cada lançamento para garantir que todo o código esteja correto e atualizado. Aqui está uma lista de executores de teste com links. O primeiro item é o que é usado por este repositório e o que que será usado para todos os exemplos nesta página.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

Instalando

Isto é muito semelhante ao que foi requerido em Install a Selenium Library. Este código está apenas a mostrar exemplos do que está a ser usado no nosso projeto de Exemplos de Documentação.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

Afirmar

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

		String title = driver.getTitle();
		assertEquals("Web form", title);

    expect(value).to eq('Received!')

Configuarar e Desconfigurar

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

	@BeforeEach
	public void setup() {
		driver = new ChromeDriver();
	}

	@AfterEach
	public void teardown() {
		driver.quit();
	}

  before do
    @driver = Selenium::WebDriver.for :chrome
  end

  config.after { @driver&.quit }

Executando

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

mvn clean test

gradle clean test

bundle exec rspec

mocha runningTests.spec.js

Examplos

In First script, we saw each of the components of a Selenium script. Here’s an example of that code using a test runner:

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

package dev.selenium.getting_started;

import static org.junit.jupiter.api.Assertions.assertEquals;

import java.time.Duration;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class UsingSeleniumTest {

	WebDriver driver;

	@BeforeEach
	public void setup() {
		driver = new ChromeDriver();
	}

	@Test
	public void eightComponents() {

		driver.manage().timeouts().implicitlyWait(Duration.ofMillis(500));
		driver.get("https://www.selenium.dev/selenium/web/web-form.html");

		String title = driver.getTitle();
		assertEquals("Web form", title);

		WebElement textBox = driver.findElement(By.name("my-text"));
		WebElement submitButton = driver.findElement(By.cssSelector("button"));

		textBox.sendKeys("Selenium");
		submitButton.click();

		WebElement message = driver.findElement(By.id("message"));
		String value = message.getText();
		assertEquals("Received!", value);

	}

	@AfterEach
	public void teardown() {
		driver.quit();
	}

}

from selenium import webdriver
from selenium.webdriver.common.by import By


def test_eight_components():
    driver = webdriver.Chrome()

    driver.get("https://www.selenium.dev/selenium/web/web-form.html")

    title = driver.title
    assert title == "Web form"

    driver.implicitly_wait(0.5)

    text_box = driver.find_element(by=By.NAME, value="my-text")
    submit_button = driver.find_element(by=By.CSS_SELECTOR, value="button")

    text_box.send_keys("Selenium")
    submit_button.click()

    message = driver.find_element(by=By.ID, value="message")
    value = message.text
    assert value == "Received!"

    driver.quit()

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace SeleniumDocs.GettingStarted
{
    [TestClass]
    public class UsingSeleniumTest
    {

        [TestMethod]
        public void EightComponents()
        {
            IWebDriver driver = new ChromeDriver();

            driver.Navigate().GoToUrl("https://www.selenium.dev/selenium/web/web-form.html");

            var title = driver.Title;
            Assert.AreEqual("Web form", title);

            driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromMilliseconds(500);

            var textBox = driver.FindElement(By.Name("my-text"));
            var submitButton = driver.FindElement(By.TagName("button"));
            
            textBox.SendKeys("Selenium");
            submitButton.Click();
            
            var message = driver.FindElement(By.Id("message"));
            var value = message.Text;
            Assert.AreEqual("Received!", value);
            
            driver.Quit();
        }
    }
}

# frozen_string_literal: true
require 'spec_helper'
require 'selenium-webdriver'


RSpec.describe 'Using Selenium' do
  before do
    @driver = Selenium::WebDriver.for :chrome
  end

  it 'uses eight components' do
    @driver.get('https://www.selenium.dev/selenium/web/web-form.html')

    title = @driver.title
    expect(title).to eq('Web form')

    @driver.manage.timeouts.implicit_wait = 500

    text_box = @driver.find_element(name: 'my-text')
    submit_button = @driver.find_element(tag_name: 'button')

    text_box.send_keys('Selenium')
    submit_button.click

    message = @driver.find_element(id: 'message')
    value = message.text
    expect(value).to eq('Received!')
  end
end

const {By, Builder} = require('selenium-webdriver');
const assert = require("assert");

  describe('First script', function () {
    let driver;
    
    before(async function () {
      driver = await new Builder().forBrowser('chrome').build();
    });
    
    it('First Selenium script with mocha', async function () {
      await driver.get('https://www.selenium.dev/selenium/web/web-form.html');
      
      let title = await driver.getTitle();
      assert.equal("Web form", title);
      
      await driver.manage().setTimeouts({implicit: 500});
      
      let textBox = await driver.findElement(By.name('my-text'));
      let submitButton = await driver.findElement(By.css('button'));
      
      await textBox.sendKeys('Selenium');
      await submitButton.click();
      
      let message = await driver.findElement(By.id('message'));
      let value = await message.getText();
      assert.equal("Received!", value);
    });
  
    after(async () => await driver.quit());
  });

Proximos passos

Pegue no que aprendeu e desenvolva o seu código Selenium!

À medida que encontrar mais funcionalidades de que precisa, leia o resto da nossa documentação do WebDriver.

2.2 - Driver Sessions

Starting and stopping a session is for opening and closing a browser.

Creating Sessions

Creating a new session corresponds with the W3C command for New session

The session is created automatically by initializing a new Driver class object.

Each language allows a session to be created with arguments from one of these classes (or equivalent):

• Options to describe the kind of session you want; default values are used for local, but this is required for remote
• Some form of Http Client Configuration (the implementation varies between languages)
• Listeners

Local Driver

The primary unique argument for starting a local driver includes information about starting the required driver service on the local machine.

• Service object applies only to local drivers and provides information about the browser driver

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

      driver = Selenium::WebDriver.for :chrome, options: options

Remote Driver

The primary unique argument for starting a remote driver includes information about where to execute the code. Read the details in the Remote Driver Section

Quitting Sessions

Quitting a session corresponds to W3C command for Deleting a Session.

Important note: the quit method is different from the close method, and it is recommended to always use quit to end the session

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

      driver.quit

2.2.1 - Opções do navegador

No Selenium 3, os recursos foram definidos em uma sessão usando classes de recursos desejados. A partir do Selenium 4, você deve usar as classes de opções do navegador. Para sessões remotas de driver, uma instância de opções do navegador é necessária, pois determina qual navegador será usado.

Essas opções são descritas na especificação w3c para Capabilities.

Cada navegador tem custom options que podem ser definidas além das definidas na especificação.

browserName

Esta capacidade é usada para definir o browserName para uma determinada sessão. Se o navegador especificado não estiver instalado no extremidade remota, a criação da sessão falhará.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

      options = Selenium::WebDriver::Options.chrome

browserVersion

Esta capacidade é opcional, é usada para defina a versão do navegador disponível na extremidade remota. Por exemplo, se solicitar o Chrome versão 75 em um sistema que tiver apenas 80 instalados, a criação da sessão falhará.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    options = Selenium::WebDriver::Options.chrome(browser_version: 'stable')

pageLoadStrategy

Três tipos de estratégias de carregamento de página estão disponíveis.

A estratégia de carregamento da página consulta o document.readyState conforme descrito na tabela abaixo:

A propriedade document.readyState de um documento descreve o estado de carregamento do documento atual.

Ao navegar para uma nova página via URL, por padrão, o WebDriver irá adiar a conclusão de uma navegação (por exemplo, driver.navigate().get()) até que o estado pronto do documento seja concluído. isso não significa necessariamente que a página terminou de carregar, especialmente para sites como Single Page Applications que usam JavaScript para carregar conteúdo dinamicamente depois que o estado Pronto retorna completo. Observe também que esse comportamento não se aplica à navegação resultante de clicar em um elemento ou enviar um formulário.

Se uma página demorar muito para carregar como resultado do download de ativos (por exemplo, imagens, css, js) que não são importantes para a automação, você pode mudar do parâmetro padrão de normal para eager ou none para acelerar a sessão. Esse valor se aplica a toda a sessão, portanto, certifique-se que sua waiting strategy é suficiente para minimizar descamação.

normal (default)

WebDriver waits until the load event fire is returned.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    ChromeOptions chromeOptions = new ChromeOptions();
    chromeOptions.setPageLoadStrategy(PageLoadStrategy.NORMAL);
    WebDriver driver = new ChromeDriver(chromeOptions);

    options.page_load_strategy = 'normal'
    driver = webdriver.Chrome(options=options)

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace pageLoadStrategy {
  class pageLoadStrategy {
    public static void Main(string[] args) {
      var chromeOptions = new ChromeOptions();
      chromeOptions.PageLoadStrategy = PageLoadStrategy.Normal;
      IWebDriver driver = new ChromeDriver(chromeOptions);
      try {
        driver.Navigate().GoToUrl("https://example.com");
      } finally {
        driver.Quit();
      }
    }
  }
}

      options = Selenium::WebDriver::Options.chrome
      options.page_load_strategy = :normal

    it('Navigate using normal page loading strategy', async function () {
      let driver = await env
        .builder()
        .setChromeOptions(options.setPageLoadStrategy('normal'))
        .build();

      await driver.get('https://www.selenium.dev/selenium/web/blank.html');

import org.openqa.selenium.PageLoadStrategy
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.chrome.ChromeOptions

fun main() {
  val chromeOptions = ChromeOptions()
  chromeOptions.setPageLoadStrategy(PageLoadStrategy.NORMAL)
  val driver = ChromeDriver(chromeOptions)
  try {
    driver.get("https://www.google.com")
  }
  finally {
    driver.quit()
  }
}

eager

WebDriver waits until DOMContentLoaded event fire is returned.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    ChromeOptions chromeOptions = new ChromeOptions();
    chromeOptions.setPageLoadStrategy(PageLoadStrategy.EAGER);
    WebDriver driver = new ChromeDriver(chromeOptions);

    options.page_load_strategy = 'eager'
    driver = webdriver.Chrome(options=options)

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace pageLoadStrategy {
  class pageLoadStrategy {
    public static void Main(string[] args) {
      var chromeOptions = new ChromeOptions();
      chromeOptions.PageLoadStrategy = PageLoadStrategy.Eager;
      IWebDriver driver = new ChromeDriver(chromeOptions);
      try {
        driver.Navigate().GoToUrl("https://example.com");
      } finally {
        driver.Quit();
      }
    }
  }
}

      options = Selenium::WebDriver::Options.chrome
      options.page_load_strategy = :eager

    it('Navigate using eager page loading strategy', async function () {
      let driver = await env
        .builder()
        .setChromeOptions(options.setPageLoadStrategy('eager'))
        .build();

      await driver.get('https://www.selenium.dev/selenium/web/blank.html');

import org.openqa.selenium.PageLoadStrategy
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.chrome.ChromeOptions

fun main() {
  val chromeOptions = ChromeOptions()
  chromeOptions.setPageLoadStrategy(PageLoadStrategy.EAGER)
  val driver = ChromeDriver(chromeOptions)
  try {
    driver.get("https://www.google.com")
  }
  finally {
    driver.quit()
  }
}

none

WebDriver only waits until the initial page is downloaded.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    ChromeOptions chromeOptions = new ChromeOptions();
    chromeOptions.setPageLoadStrategy(PageLoadStrategy.NONE);
    WebDriver driver = new ChromeDriver(chromeOptions);

    options.page_load_strategy = 'none'
    driver = webdriver.Chrome(options=options)

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace pageLoadStrategy {
  class pageLoadStrategy {
    public static void Main(string[] args) {
      var chromeOptions = new ChromeOptions();
      chromeOptions.PageLoadStrategy = PageLoadStrategy.None;
      IWebDriver driver = new ChromeDriver(chromeOptions);
      try {
        driver.Navigate().GoToUrl("https://example.com");
      } finally {
        driver.Quit();
      }
    }
  }
}

      options = Selenium::WebDriver::Options.chrome
      options.page_load_strategy = :none

    it('Navigate using none page loading strategy', async function () {
      let driver = await env
        .builder()
        .setChromeOptions(options.setPageLoadStrategy('none'))
        .build();

      await driver.get('https://www.selenium.dev/selenium/web/blank.html');

import org.openqa.selenium.PageLoadStrategy
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.chrome.ChromeOptions

fun main() {
  val chromeOptions = ChromeOptions()
  chromeOptions.setPageLoadStrategy(PageLoadStrategy.NONE)
  val driver = ChromeDriver(chromeOptions)
  try {
    driver.get("https://www.google.com")
  }
  finally {
    driver.quit()
  }
}

platformName

This identifies the operating system at the remote-end, fetching the platformName returns the OS name.

In cloud-based providers, setting platformName sets the OS at the remote-end.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

      options = Selenium::WebDriver::Options.firefox
      options.platform_name = 'Windows 10'

acceptInsecureCerts

This capability checks whether an expired (or) invalid TLS Certificate is used while navigating during a session.

If the capability is set to false, an insecure certificate error will be returned as navigation encounters any domain certificate problems. If set to true, invalid certificate will be trusted by the browser.

All self-signed certificates will be trusted by this capability by default. Once set, acceptInsecureCerts capability will have an effect for the entire session.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

timeouts

A WebDriver session is imposed with a certain session timeout interval, during which the user can control the behaviour of executing scripts or retrieving information from the browser.

Each session timeout is configured with combination of different timeouts as described below:

Script Timeout

Specifies when to interrupt an executing script in a current browsing context. The default timeout 30,000 is imposed when a new session is created by WebDriver.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

Page Load Timeout

Specifies the time interval in which web page needs to be loaded in a current browsing context. The default timeout 300,000 is imposed when a new session is created by WebDriver. If page load limits a given/default time frame, the script will be stopped by TimeoutException.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

Implicit Wait Timeout

This specifies the time to wait for the implicit element location strategy when locating elements. The default timeout 0 is imposed when a new session is created by WebDriver.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

unhandledPromptBehavior

Specifies the state of current session’s user prompt handler. Defaults to dismiss and notify state

User Prompt Handler

This defines what action must take when a user prompt encounters at the remote-end. This is defined by unhandledPromptBehavior capability and has the following states:

• dismiss
• accept
• dismiss and notify
• accept and notify
• ignore

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

setWindowRect

Indicates whether the remote end supports all of the resizing and repositioning commands.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

strictFileInteractability

This new capability indicates if strict interactability checks should be applied to input type=file elements. As strict interactability checks are off by default, there is a change in behaviour when using Element Send Keys with hidden file upload controls.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

proxy

A proxy server acts as an intermediary for requests between a client and a server. In simple, the traffic flows through the proxy server on its way to the address you requested and back.

A proxy server for automation scripts with Selenium could be helpful for:

• Capture network traffic
• Mock backend calls made by the website
• Access the required website under complex network topologies or strict corporate restrictions/policies.

If you are in a corporate environment, and a browser fails to connect to a URL, this is most likely because the environment needs a proxy to be accessed.

Selenium WebDriver provides a way to proxy settings:

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

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

public class ProxyTest {
  public static void main(String[] args) {
    Proxy proxy = new Proxy();
    proxy.setHttpProxy("<HOST:PORT>");
    ChromeOptions options = new ChromeOptions();
    options.setCapability("proxy", proxy);
    WebDriver driver = new ChromeDriver(options);
    driver.get("https://www.google.com/");
    driver.manage().window().maximize();
    driver.quit();
  }
}

from selenium import webdriver

PROXY = "<HOST:PORT>"
webdriver.DesiredCapabilities.FIREFOX['proxy'] = {
"httpProxy": PROXY,
"ftpProxy": PROXY,
"sslProxy": PROXY,
"proxyType": "MANUAL",

}

with webdriver.Firefox() as driver:
    driver.get("https://selenium.dev")

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

public class ProxyTest{
public static void Main() {
ChromeOptions options = new ChromeOptions();
Proxy proxy = new Proxy();
proxy.Kind = ProxyKind.Manual;
proxy.IsAutoDetect = false;
proxy.SslProxy = "<HOST:PORT>";
options.Proxy = proxy;
options.AddArgument("ignore-certificate-errors");
IWebDriver driver = new ChromeDriver(options);
driver.Navigate().GoToUrl("https://www.selenium.dev/");
}
}

proxy = Selenium::WebDriver::Proxy.new(http: '<HOST:PORT>')
cap   = Selenium::WebDriver::Remote::Capabilities.chrome(proxy: proxy)

driver = Selenium::WebDriver.for(:chrome, capabilities: cap)
driver.get('http://google.com')

let webdriver = require('selenium-webdriver');
let chrome = require('selenium-webdriver/chrome');
let proxy = require('selenium-webdriver/proxy');
let opts = new chrome.Options();

(async function example() {
opts.setProxy(proxy.manual({http: '<HOST:PORT>'}));
let driver = new webdriver.Builder()
.forBrowser('chrome')
.setChromeOptions(opts)
.build();
try {
await driver.get("https://selenium.dev");
}
finally {
await driver.quit();
}
}());

import org.openqa.selenium.Proxy
import org.openqa.selenium.WebDriver
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.chrome.ChromeOptions

class proxyTest {
fun main() {

        val proxy = Proxy()
        proxy.setHttpProxy("<HOST:PORT>")
        val options = ChromeOptions()
        options.setCapability("proxy", proxy)
        val driver: WebDriver = ChromeDriver(options)
        driver["https://www.google.com/"]
        driver.manage().window().maximize()
        driver.quit()
    }
}

2.2.2 - HTTP Client Configuration

These allow you to set various parameters for the HTTP library

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

2.2.3 - Driver Service Class

The Service classes are for managing the starting and stopping of drivers. They can not be used with a Remote WebDriver session.

Service classes allow you to specify information about the driver, like location and which port to use. They also let you specify what arguments get passed to the command line. Most of the useful arguments are related to logging.

Default Service instance

To start a driver with a default service instance:

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    driver = new ChromeDriver(service);
  }

    service = webdriver.ChromeService()
    driver = webdriver.Chrome(service=service)

            var service = ChromeDriverService.CreateDefaultService();
            driver = new ChromeDriver(service);

    service = Selenium::WebDriver::Service.chrome
    @driver = Selenium::WebDriver.for :chrome, service: service

Driver location

Note: If you are using Selenium 4.6 or greater, you shouldn’t need to set a driver location. If you can not update Selenium or have an advanced use case here is how to specify the driver location:

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

        new ChromeDriverService.Builder().usingDriverExecutable(driverPath).build();

    service = webdriver.ChromeService(executable_path=chromedriver_bin)

            var service = ChromeDriverService.CreateDefaultService(GetDriverLocation(options));

    service.executable_path = driver_path

Driver port

If you want the driver to run on a specific port, you may specify it as follows:

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    service = webdriver.ChromeService(port=1234)

            service.Port = 1234;

    service.port = 1234

Logging

Logging functionality varies between browsers. Most browsers allow you to specify location and level of logs. Take a look at the respective browser page:

• Chrome
• Edge
• Firefox
• Internet Explorer
• Safari

2.2.4 - Remote WebDriver

Selenium lets you automate browsers on remote computers if there is a Selenium Grid running on them. The computer that executes the code is referred to as the client computer, and the computer with the browser and driver is referred to as the remote computer or sometimes as an end-node. To direct Selenium tests to the remote computer, you need to use a Remote WebDriver class and pass the URL including the port of the grid on that machine. Please see the grid documentation for all the various ways the grid can be configured.

Basic Example

The driver needs to know where to send commands to and which browser to start on the Remote computer. So an address and an options instance are both required.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    ChromeOptions options = new ChromeOptions();
    driver = new RemoteWebDriver(gridUrl, options);

    options = webdriver.ChromeOptions()
    driver = webdriver.Remote(command_executor=server, options=options)

            var options = new ChromeOptions();
            driver = new RemoteWebDriver(GridUrl, options);

    options = Selenium::WebDriver::Options.chrome
    driver = Selenium::WebDriver.for :remote, url: grid_url, options: options

Uploads

Uploading a file is more complicated for Remote WebDriver sessions because the file you want to upload is likely on the computer executing the code, but the driver on the remote computer is looking for the provided path on its local file system. The solution is to use a Local File Detector. When one is set, Selenium will bundle the file, and send it to the remote machine, so the driver can see the reference to it. Some bindings include a basic local file detector by default, and all of them allow for a custom file detector.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    ((RemoteWebDriver) driver).setFileDetector(new LocalFileDetector());
    WebElement fileInput = driver.findElement(By.cssSelector("input[type=file]"));
    fileInput.sendKeys(uploadFile.getAbsolutePath());
    driver.findElement(By.id("file-submit")).click();

    driver.file_detector = LocalFileDetector()
    file_input = driver.find_element(By.CSS_SELECTOR, "input[type='file']")
    file_input.send_keys(upload_file)
    driver.find_element(By.ID, "file-submit").click()

            ((RemoteWebDriver)driver).FileDetector = new LocalFileDetector();
            IWebElement fileInput = driver.FindElement(By.CssSelector("input[type=file]"));
            fileInput.SendKeys(uploadFile);
            driver.FindElement(By.Id("file-submit")).Click();

    driver.file_detector = ->((filename, *)) { filename.include?('selenium') && filename }
    file_input = driver.find_element(css: 'input[type=file]')
    file_input.send_keys(upload_file)
    driver.find_element(id: 'file-submit').click

Downloads

Chrome, Edge and Firefox each allow you to set the location of the download directory. When you do this on a remote computer, though, the location is on the remote computer’s local file system. Selenium allows you to enable downloads to get these files onto the client computer.

Enable Downloads in the Grid

Regardless of the client, when starting the grid in node or standalone mode, you must add the flag:

--enable-managed-downloads true

Enable Downloads in the Client

The grid uses the se:downloadsEnabled capability to toggle whether to be responsible for managing the browser location. Each of the bindings have a method in the options class to set this.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    ChromeOptions options = new ChromeOptions();
    options.setEnableDownloads(true);
    driver = new RemoteWebDriver(gridUrl, options);

    options = webdriver.ChromeOptions()
    options.enable_downloads = True
    driver = webdriver.Remote(command_executor=server, options=options)

            ChromeOptions options = new ChromeOptions
            {
                EnableDownloads = true
            };

            driver = new RemoteWebDriver(GridUrl, options);

    options = Selenium::WebDriver::Options.chrome(enable_downloads: true)
    driver = Selenium::WebDriver.for :remote, url: grid_url, options: options

List Downloadable Files

Be aware that Selenium is not waiting for files to finish downloading, so the list is an immediate snapshot of what file names are currently in the directory for the given session.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    List<String> files = ((HasDownloads) driver).getDownloadableFiles();

    files = driver.get_downloadable_files()

            IReadOnlyList<string> names = ((RemoteWebDriver)driver).GetDownloadableFiles();

    files = driver.downloadable_files

Download a File

Selenium looks for the name of the provided file in the list and downloads it to the provided target directory.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    ((HasDownloads) driver).downloadFile(downloadableFile, targetDirectory);

    driver.download_file(downloadable_file, target_directory)

            ((RemoteWebDriver)driver).DownloadFile(downloadableFile, targetDirectory);

    driver.download_file(downloadable_file, target_directory)

Delete Downloaded Files

By default, the download directory is deleted at the end of the applicable session, but you can also delete all files during the session.

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    ((HasDownloads) driver).deleteDownloadableFiles();

    driver.delete_downloadable_files()

            ((RemoteWebDriver)driver).DeleteDownloadableFiles();

    driver.delete_downloadable_files

Browser specific functionalities

Each browser has implemented special functionality that is available only to that browser. Each of the Selenium bindings has implemented a different way to use those features in a Remote Session

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    driver = new Augmenter().augment(driver);

        RemoteWebDriver.builder()
            .address(gridUrl)
            .oneOf(new ChromeOptions())
            .setCapability("ext:options", Map.of("key", "value"))
            .config(ClientConfig.defaultConfig())
            .build();

            var customCommandDriver = driver as ICustomDriverCommandExecutor;
            customCommandDriver.RegisterCustomDriverCommands(FirefoxDriver.CustomCommandDefinitions);

            var screenshotResponse = customCommandDriver
                .ExecuteCustomDriverCommand(FirefoxDriver.GetFullPageScreenshotCommand, null);

Tracing client requests

This feature is only available for Java client binding (Beta onwards). The Remote WebDriver client sends requests to the Selenium Grid server, which passes them to the WebDriver. Tracing should be enabled at the server and client-side to trace the HTTP requests end-to-end. Both ends should have a trace exporter setup pointing to the visualization framework. By default, tracing is enabled for both client and server. To set up the visualization framework Jaeger UI and Selenium Grid 4, please refer to Tracing Setup for the desired version.

For client-side setup, follow the steps below.

Add the required dependencies

Installation of external libraries for tracing exporter can be done using Maven. Add the opentelemetry-exporter-jaeger and grpc-netty dependency in your project pom.xml:

  <dependency>
      <groupId>io.opentelemetry</groupId>
      <artifactId>opentelemetry-exporter-jaeger</artifactId>
      <version>1.0.0</version>
    </dependency>
    <dependency>
      <groupId>io.grpc</groupId>
      <artifactId>grpc-netty</artifactId>
      <version>1.35.0</version>
    </dependency>

Add/pass the required system properties while running the client

• Java

System.setProperty("otel.traces.exporter", "jaeger");
System.setProperty("otel.exporter.jaeger.endpoint", "http://localhost:14250");
System.setProperty("otel.resource.attributes", "service.name=selenium-java-client");

ImmutableCapabilities capabilities = new ImmutableCapabilities("browserName", "chrome");

WebDriver driver = new RemoteWebDriver(new URL("http://www.example.com"), capabilities);

driver.get("http://www.google.com");

driver.quit();

Please refer to Tracing Setup for more information on external dependencies versions required for the desired Selenium version.

More information can be found at:

• OpenTelemetry: https://opentelemetry.io
• Configuring OpenTelemetry: https://github.com/open-telemetry/opentelemetry-java/tree/main/sdk-extensions/autoconfigure
• Jaeger: https://www.jaegertracing.io
• Selenium Grid Observability

2.3 - Navegadores suportados

Cada navegador tem capacidades e características únicas.

2.3.1 - Funcionalidade específica do Chrome

Por omissão, Selenium 4 é compatível com Chrome v75 e superiores. Note que a versão (maior) do navegador e do chromedriver devem ser idênticas.

Opções

Capacidades comuns a todos os navegadores estão descritas na página Opções.

Capacidades únicas ao Chrome podem ser encontradas na página da Google para Capacidades e & ChromeOptions

Este é um exemplo de como iniciar uma sessão Chrome com um conjunto de opções básicas:

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    driver = new ChromeDriver(options);
  }

    options = webdriver.ChromeOptions()
    driver = webdriver.Chrome(options=options)

            var options = new ChromeOptions();
            driver = new ChromeDriver(options);

      options = Selenium::WebDriver::Options.chrome
      @driver = Selenium::WebDriver.for :chrome, options: options

      const Options = new Chrome.Options();
      let driver = await env
        .builder()
        .setChromeOptions(Options)
        .build();

Alguns exemplos de uso com capacidades diferentes:

Argumentos

The args parameter is for a list of command line switches to be used when starting the browser. There are two excellent resources for investigating these arguments:

• Chrome Flags for Tooling
• List of Chromium Command Line Switches

Commonly used args include --start-maximized, --headless=new and --user-data-dir=...

Add an argument to options:

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    options.add_argument("--start-maximized")

            options.AddArgument("--start-maximized");

      options.args << '--start-maximized'

      let driver = await env
        .builder()
        .setChromeOptions(options.addArguments('--headless=new'))
        .build();

Iniciar navegador numa localização específica

Adicionar uma localização:

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    options.binary_location = chrome_bin

            options.BinaryLocation = GetChromeLocation();

      options.binary = chrome_location

      let driver = await env
        .builder()
        .setChromeOptions(options.setChromeBinaryPath(`Path to chrome binary`))
        .build();

Adicionar extensões

O parametro extensions aceita ficheiros crx

The extensions parameter accepts crx files. As for unpacked directories, please use the load-extension argument instead, as mentioned in this post.

Adicionar uma extensão:

• Java
• Python
• CSharp
• Ruby
• JavaScript
• Kotlin

    options.add_extension(extension_file_path)

            options.AddExtension(extensionFilePath);