WebDriver

• 1: Começando
• 1.1: Instalando bibliotecas do Selenium
• 1.2: Installing browser drivers
• 1.3: Open and close a browser with Selenium
• 1.4: Write your first Selenium script
• 1.5: Como atualizar para Selenium 4
• 2: Capabilities
• 2.1: Recursos compartilhados
• 2.2: Capabilities specific to Chromium browsers
• 2.3: Capabilities specific to Firefox browser
• 2.4: Capabilities specific to Internet Explorer browser
• 2.5: Capabilities specific to Safari browser
• 3: Manipulação do Browser
• 3.1: Browser navigation
• 3.2: Alertas, prompts e confirmações JavaScript
• 3.3: Trabalhando com cookies
• 3.4: Working with iFrames and frames
• 3.5: Working with windows and tabs
• 4: Elemento Web
• 4.1: Finding web elements
• 4.2: Interacting with web elements
• 4.3: Information about web elements
• 4.4: Localizando elementos
• 4.5: Trabalhando com elementos select
• 5: Remote WebDriver
• 6: Configuring driver parameters
• 7: Esperas
• 8: Actions API
• 8.1: Teclado
• 8.2: Ações do mouse em detalhe
• 8.3: Scroll wheel actions
• 9: BiDirectional Functionality
• 9.1: Chrome DevTools Protocol
• 9.2: BiDirectional API
• 10: Additional Features
• 10.1: Trabalhando com cores
• 10.2: ThreadGuard

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.

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.

A instalação do Selenium é dividida nas etapas:

1. Instalando a biblioteca Selenium para sua linguagem de programação escolhida.
2. Configure o driver para o navegador para automatizar o navegador (ex. GeckoDriver para Firefox).
3. (Opcional) Escolha e configure Selenium Grid se você quiser tornar seus testes escaláveis.

Se você deseja iniciar com ferramenta low-code / gravação e reprodução, por favor veja: Selenium IDE

After completing the setup, you can run the code snippet shown at the Depois de completar as etapas de configuração, você pode executar o snippet de codigo em starting page na documentação. Então siga para seção WebDriver para aprender mais sobre automação de navegadores com Selenium.

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.

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

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

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

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

pip install selenium

python setup.py install

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

<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

npm install selenium-webdriver

Próximo passo

Instale os drivers do navegador

1.2 - Installing browser drivers

Through WebDriver, Selenium supports all major browsers on the market such as Chrome/Chromium, Firefox, Internet Explorer, Edge, Opera, and Safari. Where possible, WebDriver drives the browser using the browser’s built-in support for automation.

Since all the driver implementations except for Internet Explorer are provided by the browser vendors themselves, they are not included in the standard Selenium distribution. This section explains the basic requirements for getting you started with the different browsers.

Read about more advanced options for starting a driver in our driver configuration documentation.

Quick Reference

Note: The Opera driver does not support w3c syntax, so we recommend using chromedriver to work with Opera. See the code example for opening an Opera browser.

Three Ways to Use Drivers

1. Driver Management Software

Most machines automatically update the browser, but the driver does not. To make sure you get the correct driver for your browser, there are many third party libraries to assist you.

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

import io.github.bonigarcia.wdm.WebDriverManager;

WebDriverManager.chromedriver().setup();

ChromeDriver driver = new ChromeDriver();

from webdriver_manager.chrome import ChromeDriverManager

service = Service(executable_path=ChromeDriverManager().install())

driver = webdriver.Chrome(service=service)

using WebDriverManager;
using WebDriverManager.DriverConfigs.Impl;

new DriverManager().SetUpDriver(new ChromeConfig());

var driver = new ChromeDriver()

gem 'webdrivers', '~> 5.0'

require 'webdrivers'

driver = Selenium::WebDriver.for :chrome

import io.github.bonigarcia.wdm.WebDriverManager;

fun chrome(): WebDriver {
    WebDriverManager.chromedriver().setup()
    return ChromeDriver()
}

2. The PATH Environment Variable

This option first requires manually downloading the driver (See Quick Reference Section for links).

This is a flexible option to change location of drivers without having to update your code, and will work on multiple machines without requiring that each machine put the drivers in the same place.

You can either place the drivers in a directory that is already listed in PATH, or you can place them in a directory and add it to PATH.

• Bash
• Zsh
• Windows

echo $PATH

echo 'export PATH=$PATH:/path/to/driver' >> ~/.bash_profile
source ~/.bash_profile

chromedriver

echo $PATH

echo 'export PATH=$PATH:/path/to/driver' >> ~/.zshenv
source ~/.zshenv

chromedriver

echo %PATH%

setx PATH "%PATH%;C:\WebDriver\bin"

chromedriver.exe

If your PATH is configured correctly above, you will see some output relating to the startup of the driver:

Starting ChromeDriver 95.0.4638.54 (d31a821ec901f68d0d34ccdbaea45b4c86ce543e-refs/branch-heads/4638@{#871}) on port 9515
Only local connections are allowed.
Please see https://chromedriver.chromium.org/security-considerations for suggestions on keeping ChromeDriver safe.
ChromeDriver was started successfully.

You can regain control of your command prompt by pressing Ctrl+C

3. Hard Coded Location

Similar to Option 2 above, you need to manually download the driver (See Quick Reference Section for links). Specifying the location in the code itself has the advantage of not needing to figure out Environment Variables on your system, but has the drawback of making the code much less flexible.

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

System.setProperty("webdriver.chrome.driver","/path/to/chromedriver");
ChromeDriver driver = new ChromeDriver();

service = Service(executable_path="/path/to/chromedriver")
driver = webdriver.Chrome(service=service)

var driver = new ChromeDriver(@"C:\WebDriver\bin");

service = Selenium::WebDriver::Service.chrome(path: '/path/to/chromedriver')
driver = Selenium::WebDriver.for :chrome, service: service

const {Builder} = require('selenium-webdriver');
const chrome = require('selenium-webdriver/chrome');

const service = new chrome.ServiceBuilder('/path/to/chromedriver');
const driver = new Builder().forBrowser('chrome').setChromeService(service).build();

import org.openqa.selenium.chrome.ChromeDriver

fun main(args: Array<String>) {
    System.setProperty("webdriver.chrome.driver", "/path/to/chromedriver")
    val driver = ChromeDriver()
}

Advanced Configuration

More information on how you can change the driver behavior can be found on the Configuring driver parameters page.

Next Step

Open and close a browser

1.3 - Open and close a browser with Selenium

Once you have a Selenium library installed, and your desired browser driver, you can start and stop a session with a browser.

Typically, browsers are started with specific options that describe which capabilities the browser must support, and how the browser should behave during the session. Some capabilities are shared by all browsers, and some will be specific to the browser being used. This page will show examples of starting a browser with the default capabilities.

After learning how to start a session, check out the next session on how to write your first Selenium script

Chrome

By default, Selenium 4 is compatible with Chrome v75 and greater. Note that the version of the Chrome browser and the version of chromedriver must match the major version.

In addition to the shared capabilities, there are specific Chrome capabilities that can be used.

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

  ChromeOptions options = new ChromeOptions();
  driver = new ChromeDriver(options);
  
  driver.quit();
  

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

  driver.quit()
  

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

  driver.Quit();
  

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

  driver.quit
  

const {Builder} = require('selenium-webdriver');
const chrome = require('selenium-webdriver/chrome');

(async function openChromeTest() {
  try {
    let options = new chrome.Options();
    let driver = await new Builder()
                .setChromeOptions(options)
                .forBrowser('chrome')
                .build();
    await driver.get('https://www.google.com');
    await driver.quit();
  } catch (error) {
    console.log(error)
  }
})();

  val options = ChromeOptions()
  val driver = ChromeDriver(options)

  driver.quit()
  

Edge

Microsoft Edge is implemented with Chromium, with the earliest supported version of v79. Similar to Chrome, the major version number of edgedriver must match the major version of the Edge browser.

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

  EdgeOptions options = new EdgeOptions();
  driver = new EdgeDriver(options);

  driver.quit();
  

  options = EdgeOptions()
  driver = webdriver.Edge(options=options)

  driver.quit()
  

  var options = new EdgeOptions();
  var driver = new EdgeDriver(options);
  
  driver.Quit();
  

  options = Selenium::WebDriver::Options.edge
  driver = Selenium::WebDriver.for :edge, options: options

  driver.quit
  

const {Builder} = require('selenium-webdriver');
const edge = require('selenium-webdriver/edge');

(async function openEdgeTest() {
  try {
    let options = new edge.Options();
    let driver = await new Builder()
                .setChromeOptions(options)
                .forBrowser('edge')
                .build();
    await driver.get('https://www.google.com');
    await driver.quit();
  } catch (error) {
    console.log(error)
  }
})();

  val options = EdgeOptions()
  val driver = EdgeDriver(options)

  driver.quit()
  

Firefox

Selenium 4 requires Firefox 78 or greater. It is recommended to always use the latest version of geckodriver.

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

  FirefoxOptions options = new FirefoxOptions();
  driver = new FirefoxDriver(options);

  driver.quit();
  

  options = FirefoxOptions()
  driver = webdriver.Firefox(options=options)

  driver.quit()
  

  var options = new FirefoxOptions();
  var driver = new FirefoxDriver(options);
  
  driver.Quit();
  

  options = Selenium::WebDriver::Options.firefox
  driver = Selenium::WebDriver.for :firefox, options: options

  driver.quit
  

const {Builder} = require('selenium-webdriver');
const firefox = require('selenium-webdriver/firefox');

(async function openFirefoxTest() {
  try {
    let options = new firefox.Options();
    let driver = await new Builder()
                .setChromeOptions(options)
                .forBrowser('firefox')
                .build();
    await driver.get('https://www.google.com');
    await driver.quit();
  } catch (error) {
    console.log(error)
  }
})();

  val options = FirefoxOptions()
  val driver = FirefoxDriver(options)

  driver.quit()
  

Internet Explorer

The IE Driver is the only driver maintained by the Selenium Project directly. While binaries for both the 32-bit and 64-bit versions of Internet Explorer are available, there are some limitations with the 64-bit driver. As such it is recommended to use the 32-bit driver.

Legacy

The Selenium project aims to support the same releases that Microsoft considers current. Older releases may work, but will not be supported. Note that Internet Explorer 11 will end support for certain operating systems, including Windows 10 on June 15, 2022.

It should be noted that as Internet Explorer preferences are saved against the logged-in user’s account, some additional setup is required.

Additional information about using Internet Explorer can be found on the Selenium wiki

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

  InternetExplorerOptions options = new InternetExplorerOptions();
  driver = new InternetExplorerDriver(options);

  driver.quit();
  

  options = IEOptions()
  driver = webdriver.Ie(options=options)

  driver.quit()
  

  var options = new InternetExplorerOptions();
  var driver = new InternetExplorerDriver(options);
  
  driver.Quit();
  

  options = Selenium::WebDriver::Options.ie
  driver = Selenium::WebDriver.for :ie, options: options

  driver.quit
  

  const { Builder } = require("selenium-webdriver");
  const ie = require('selenium-webdriver/ie');

  let options = new ie.Options();
  let driver = await new Builder()
    .forBrowser('internetExplorer')
    .setIeOptions(options)
    .build();

  await driver.quit();
 

  val options = InternetExplorerOptions()
  val driver = InternetExplorerDriver(options)

  driver.quit()
  

Compatibility Mode

Microsoft Edge can be used in IE compatibility mode using the IE Driver.

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

  InternetExplorerOptions options = new InternetExplorerOptions();
  options.attachToEdgeChrome();
  options.withEdgeExecutablePath("/path/to/edge/browser");
  
  driver = new InternetExplorerDriver(options);
  
  driver.quit();
  

  options = IEOptions()
  options.attach_to_edge_chrome = True
  options.edge_executable_path = "/path/to/edge/browser"
  driver = webdriver.Ie(options=options)

  driver.quit()
  

  var options = new InternetExplorerOptions
  {
    AttachToEdgeChrome = true,
    EdgeExecutablePath = "/path/to/edge/browser"
  };
  var driver = new InternetExplorerDriver(options);
  
  driver.Quit();
  

  options = Selenium::WebDriver::Options.ie
  options.attach_to_edge_chrome = true
  options.edge_executable_path = "/path/to/edge/browser"
  driver = Selenium::WebDriver.for :ie, options: options

  driver.quit
  

  let options = new ie.Options();
  options.setEdgeChromium(true);
  options.setEdgePath("/path/to/edge/browser);

  let driver = await new Builder()
    .forBrowser('internet explorer')
    .setIEOptions(options)
    .build();

  await driver.quit();
  

  val options = InternetExplorerOptions()
  options.attachToEdgeChrome()
  options.withEdgeExecutablePath("/path/to/edge/browser")
  val driver = InternetExplorerDriver(options)

  driver.quit()
  

Opera

Since the opera driver does not support w3c syntax, but is based on Chromium, it is recommended to drive Opera browser with the chromedriver. Like all Chromium implementations, make sure that the browser version matches the driver version.

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

  ChromeOptions options = new ChromeOptions();
  options.setBinary("/path/to/opera/browser");
  
  driver = new ChromeDriver(options);
  
  driver.quit();
  

  options = ChromeOptions()
  options.binary_location = "path/to/opera/browser"
  driver = webdriver.Chrome(options=options)

  driver.quit()
  

  var options = new ChromeOptions
  {
    BinaryLocation = "/path/to/opera/browser"
  };
  var driver = new ChromeDriver(options);
  
  driver.Quit();
  

  options = Selenium::WebDriver::Options.chrome
  options.binary = '/path/to/opera/browser'
  driver = Selenium::WebDriver.for :chrome, options: options

  driver.quit
  

  const { Builder } = require("selenium-webdriver");
  const chrome = require('selenium-webdriver/chrome');

  let options = new chrome.Options();
  options.setChromeBinaryPath("/path/to/opera/browser");

  let driver = await new Builder()
    .forBrowser('chrome')
    .setChromeOptions(options)
    .build();

  await driver.quit();
  

  val options = ChromeOptions()
  options.setBinary("/path/to/opera/browser")
  val driver = ChromeDriver(options)
  
  driver.quit()
  

Safari

Desktop

Unlike Chromium and Firefox drivers, the safaridriver is installed with the Operating System. To enable automation on Safari, run the following command from the terminal:

safaridriver --enable

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

  SafariOptions options = new SafariOptions();
  driver = new SafariDriver(options);
  
  driver.quit();

  driver = webdriver.Safari()

  driver.quit()
  

  var options = new SafariOptions();
  var driver = new SafariDriver(options);

  driver.Quit();
  

  options = Selenium::WebDriver::Options.safari
  driver = Selenium::WebDriver.for :safari, options: options

  driver.quit
  

  const { Builder } = require("selenium-webdriver");
  const safari = require('selenium-webdriver/safari');

  let options = new safari.Options();
  let driver = await new Builder()
    .forBrowser('safari')
    .setSafariOptions(options)
    .build();

  await driver.quit();
  

  val options = SafariOptions()
  val driver = SafariDriver(options)

  driver.quit()
  

Mobile

Those looking to automate Safari on iOS should look to the Appium project.

Next Step

Create your first Selenium script

1.4 - Write your first Selenium script

Once you have Selenium installed and Drivers installed, you’re ready to write Selenium code.

Eight Basic Components

Everything Selenium does is send the browser commands to do something or send requests for information. Most of what you’ll do with Selenium is a combination of these basic commands:

1. Start the session

For more details on starting a session read our documentation on opening and closing a browser

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

        driver = new ChromeDriver();

    driver = webdriver.Chrome()

            var driver = new ChromeDriver();

    driver = Selenium::WebDriver.for :chrome

    let driver = await new Builder().forBrowser('chrome').build();

        driver = ChromeDriver()

2. Take action on browser

In this example we are navigating to a web page.

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

        driver.get("https://google.com");

    driver.get("https://google.com")

            driver.Navigate().GoToUrl("https://google.com");

    driver.get('https://google.com')

    await driver.get('https://www.google.com');

        driver.get("https://google.com")

3. Request browser information

There are a bunch of types of information about the browser you can request, including window handles, browser size / position, cookies, alerts, etc.

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

        String title = driver.getTitle();

    title = driver.title

            var title = driver.Title;

    title = driver.title

    await driver.getTitle();

        title = driver.title

4. Establish Waiting Strategy

Synchronizing the code with the current state of the browser is one of the biggest challenges with Selenium, and doing it well is an advanced topic.

Essentially you want to make sure that the element is on the page before you attempt to locate it and the element is in an interactable state before you attempt to interact with it.

An implicit wait is rarely the best solution, but it’s the easiest to demonstrate here, so we’ll use it as a placeholder.

Read more about Waiting strategies.

• 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

    driver.manage().setTimeouts({implicit: 1000})

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

5. Find an element

The majority of commands in most Selenium sessions are element related, and you can’t interact with one without first finding an element

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

        WebElement searchBox = driver.findElement(By.name("q"));
        WebElement searchButton = driver.findElement(By.name("btnK"));

    search_box = driver.find_element(by=By.NAME, value="q")
    search_button = driver.find_element(by=By.NAME, value="btnK")

            var searchBox = driver.FindElement(By.Name("q"));
            var searchButton = driver.FindElement(By.Name("btnK"));

    search_box = driver.find_element(name: 'q')
    search_button = driver.find_element(name: 'btnK')

    let searchBox = await driver.findElement(By.name('q'));
    let searchButton = await driver.findElement(By.name('btnK'));

        var searchBox = driver.findElement(By.name("q"))
        val searchButton = driver.findElement(By.name("btnK"))

6. Take action on element

There are only a handful of actions to take on an element, but you will use them frequently.

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

        searchBox.sendKeys("Selenium");
        searchButton.click();

    search_box.send_keys("Selenium")
    search_button.click()

            searchBox.SendKeys("Selenium");
            searchButton.Click();

    search_box.send_keys('Selenium')
    search_button.click

    await searchBox.sendKeys('Selenium');
    await searchButton.click();

        searchBox.sendKeys("Selenium")
        searchButton.click()

7. Request element information

Elements store a lot of information that can be requested. Notice that we need to relocate the search box because the DOM has changed since we first located it.

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

        String value = searchBox.getAttribute("value")

    value = search_box.get_attribute("value")

            var value = searchBox.GetAttribute("value");

    value = search_box.attribute('value')

    let value = search_box.getAttribute("value");

        val value = searchBox.getAttribute("value")

8. End the session

This ends the driver process, which by default closes the browser as well. No more commands can be sent to this driver instance.

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

        driver.quit();

    driver.quit()

            driver.Quit();

    driver.quit

    await driver.quit();

        driver.quit()

Putting everything together

Let’s combine these 8 things into a complete script with assertions that can be executed by a test runner.

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

package dev.selenium.getting_started;

import org.junit.jupiter.api.Assertions;
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;

import java.time.Duration;

public class FirstScriptTest {
    public WebDriver driver;

    @Test
    public void eightComponents() {
        driver = new ChromeDriver();

        driver.get("https://google.com");

        String title = driver.getTitle();
        Assertions.assertEquals("Google", title);

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

        WebElement searchBox = driver.findElement(By.name("q"));
        WebElement searchButton = driver.findElement(By.name("btnK"));

        searchBox.sendKeys("Selenium");
        searchButton.click();

        searchBox = driver.findElement(By.name("q"));
        String value = searchBox.getAttribute("value")
        Assertions.assertEquals("Selenium", value);

        driver.quit();
    }
}

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


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

    driver.get("https://google.com")

    title = driver.title
    assert title == "Google"

    driver.implicitly_wait(0.5)

    search_box = driver.find_element(by=By.NAME, value="q")
    search_button = driver.find_element(by=By.NAME, value="btnK")

    search_box.send_keys("Selenium")
    search_button.click()

    search_box = driver.find_element(by=By.NAME, value="q")
    value = search_box.get_attribute("value")
    assert value == "Selenium"

    driver.quit()

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

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

        [TestMethod]
        public void ChromeSession()
        {
            var driver = new ChromeDriver();

            driver.Navigate().GoToUrl("https://google.com");

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

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

            var searchBox = driver.FindElement(By.Name("q"));
            var searchButton = driver.FindElement(By.Name("btnK"));
            
            searchBox.SendKeys("Selenium");
            searchButton.Click();
            
            searchBox = driver.FindElement(By.Name("q"));
            var value = searchBox.GetAttribute("value");
            Assert.AreEqual("Selenium", value);

            driver.Quit();
        }
    }
}

# frozen_string_literal: true

RSpec.describe 'First Script' do
  it 'uses eight components' do
    driver = Selenium::WebDriver.for :chrome

    driver.get('https://google.com')

    title = driver.title
    expect(title).to eq('Google')

    driver.manage.timeouts.implicit_wait = 500

    search_box = driver.find_element(name: 'q')
    search_button = driver.find_element(name: 'btnK')

    search_box.send_keys('Selenium')
    search_button.click

    search_box = driver.find_element(name: 'q')
    value = search_box.attribute('value')
    expect(value).to eq('Selenium')

    driver.quit
  end
end

const {Builder, By, Key, until} = require('selenium-webdriver');

(async function firstScript() {
  try {
    let driver = await new Builder().forBrowser('chrome').build();

    await driver.get('https://www.google.com');

    await driver.getTitle();

    driver.manage().setTimeouts({implicit: 1000})

    let searchBox = await driver.findElement(By.name('q'));
    let searchButton = await driver.findElement(By.name('btnK'));

    await searchBox.sendKeys('Selenium');
    await searchButton.click();

    let search_box = driver.findElement(By.name('q'))
    let value = search_box.getAttribute("value");

    await driver.quit();
  } catch (error) {
    console.log(error)
  }
})();

package dev.selenium.getting_started

import io.github.bonigarcia.wdm.WebDriverManager
import org.junit.jupiter.api.*
import org.junit.jupiter.api.Assertions.assertEquals
import org.openqa.selenium.By
import org.openqa.selenium.WebDriver
import org.openqa.selenium.chrome.ChromeDriver
import java.time.Duration

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class FirstScriptTest {
    private lateinit var driver: WebDriver

    @Test
    fun eightComponents() {
        driver = ChromeDriver()

        driver.get("https://google.com")

        title = driver.title
        assertEquals("Google", title)

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

        var searchBox = driver.findElement(By.name("q"))
        val searchButton = driver.findElement(By.name("btnK"))

        searchBox.sendKeys("Selenium")
        searchButton.click()

        searchBox = driver.findElement(By.name("q"))
        val value = searchBox.getAttribute("value")
        assertEquals("Selenium", value)

        driver.quit()
    }
}

Next Steps

Take what you’ve learned and build out your Selenium code.

As you find more functionality that you need, read up on the rest of our WebDriver documentation.

1.5 - Como atualizar para Selenium 4

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

• Java
• JavaScript
• CSharp
• Ruby
• Python

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), caps);

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

• Java
• JavaScript
• CSharp
• Ruby
• Python

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), browserOptions);

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*

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

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*

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

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

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

<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

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

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

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

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

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

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.

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

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

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.

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

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:

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

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

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)

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

2 - Capabilities

2.1 - Recursos compartilhados

Para criar uma nova sessão por Selenium WebDriver, a extremidade local deve fornecer os recursos básicos para a extremidade remota. A extremidade remota usa o mesmo conjunto de recursos para cria uma sessão e descreve os recursos da sessão atual.

WebDriver fornece recursos que cada controle extremidade remota irá/deverá apoiar a implementação. A seguir estão os recursos que o WebDriver suporta:

browserName:

Este recurso é usado para definir o browserName para uma determinada sessão. Se o navegador especificado não estiver instalado na extremidade remota, a criação da sessão irá falhar

browserVersion:

Este recurso é opcional, usado para definir a versão do navegador disponível na extremidade remota. Por exemplo, se pedir o Chrome versão 75 em um sistema que tem apenas a versão 80 instalada, a criação da sessão irá falhar

pageLoadStrategy:

Ao navegar para uma nova página via URL, por padrão o Selenium irá esperar até que a página esteja totalmente carregada antes de responder. Isso funciona bem para iniciantes, mas pode causar longos tempos de espera em páginas que carregam um grande número de recursos de terceiros. Usar uma estratégia não padrão pode tornar a execução de testes mais rápida em casos como este, mas também pode apresentar instabilidade onde os elementos na página mudam de posição conforme os elementos são carregados e mudam de tamanho.

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

platformName

Isso identifica o sistema operacional na extremidade remota e buscar o platformName retorna o nome do sistema operacional.

Em provedores baseados em nuvem, definir platformName define o sistema operacional na extremidade remota.

acceptInsecureCerts

Este recurso verifica se um Certificado TLS expirado (ou) inválido é usado durante a navegação durante uma sessão.

Se o recurso for definido como false, um erro de certificado inseguro será retornado quando a navegação encontrar qualquer problema de certificado de domínio. Se definido como verdadeiro, o certificado inválido será confiável para o navegador.

Todos os certificados autoassinados serão considerados confiáveis por esse recurso por padrão. Uma vez definido, o recurso acceptInsecureCerts terá um efeito para toda a sessão.

timeout

Uma session do WebDriver é imposta com um certo intervalo session timeout durante o qual o usuário pode controlar o comportamento de executar scripts ou recuperar informações do navegador.

Cada tempo limite de sessão é configurado com combinação de diferentes timeouts, conforme descrito abaixo:

Timeout de Script:

Especifica quando interromper um script em execução em um contexto de navegação atual. O tempo limite padrão 30.000 é imposto quando uma nova sessão é criada pelo WebDriver.

Timeout de Carregamento de Página:

Especifica o intervalo de tempo em que a página da web precisa ser carregado em um contexto de navegação atual. O tempo limite padrão 300.000 é imposto quando uma nova sessão é criada pelo WebDriver. Se os carregamento da página delimitar um determinado período de tempo, o script será interrompido por TimeoutException.

Timeout de Espera Implícita:

Isso especifica o tempo de espera pela estratégia de implicit element location quando localizando de elementos. O tempo limite padrão 0 é imposto quando uma nova sessão é criada pelo WebDriver.

unhandledPromptBehavior

Especifica o estado do user prompt handler da sessão atual. O padrão é dismiss and notify state (dispensar e notificar estado, em português)

User Prompt Handler

Isso define qual ação deve ser tomada quando um o prompt do usuário se encontra na extremidade remota. Isso é definido pelo recurso unhandledPromptBehavior e tem os seguintes estados:

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

setWindowRect

Este comando altera o tamanho e a posição da atual janela de contexto de navegação. Este comando atua como setter para o comando getWindowRect que aceita largura, altura, x, y como argumentos opcionais.

Durante a automação, o contexto de navegação atual será associado com estados de janela, que descrevem a visibilidade da janela do navegador. Os estados da janela são

• maximized
• minimized
• normal
• fullscreen

Definir Width ou Height não garante que o resultado o tamanho da janela corresponderá exatamente ao que foi inserido. Isto é porque alguns drivers podem não ser redimensionados em incrementos de pixel único. Devido a isso, buscar o estado / detalhes da janela por getWindowRect pode não corresponder igualmente aos valores definidos para o navegador.

strictFileInteractability

O novo recurso indica se as verificações estritas de interatividade devem ser aplicadas aos elementos input type = file. Como as verificações de interatividade estrita estão desativadas por padrão, há uma mudança no comportamento ao usar Element Send Keys com controles de upload de arquivos ocultos.

proxy

Um servidor proxy atua como intermediário para solicitações entre um cliente e um servidor. De forma simples, o tráfego flui através do servidor proxy a caminho do endereço que você solicitou e de volta.

Um servidor proxy para scripts de automação com Selenium pode ser útil para:

• Capturar o tráfego da rede
• Simular chamadas de back-end feitas pelo site
• Acessar o site necessário em uma rede complexa topologias ou restrições / políticas corporativas estritas.

Se você estiver em um ambiente corporativo, e um navegador não consegue se conectar a um URL, isso é provavelmente porque o ambiente precisa de um proxy para ser acessado.

O Selenium WebDriver fornece uma maneira de configurações de proxy:

• 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:
# Open URL
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/");
}
}

# este código foi escrito com Selenium 4

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