Sessões de Driver

from selenium import webdriver


def test_page_load_strategy_normal():
    options = webdriver.ChromeOptions()

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

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


def test_page_load_strategy_eager():
    options = webdriver.ChromeOptions()

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

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


def test_page_load_strategy_none():
    options = webdriver.ChromeOptions()

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

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

using System;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace SeleniumDocs
{
    public class BaseTest
    {
        protected IWebDriver driver;
        protected Uri GridUrl;
        private Process _webserverProcess;
        private const string ServerJarName = "selenium-server-4.34.0.jar";
        private static readonly string BaseDirectory = AppContext.BaseDirectory;
        private const string RelativePathToGrid = "../../../../../";
        private readonly string _examplesDirectory = Path.GetFullPath(Path.Combine(BaseDirectory, RelativePathToGrid));

        [TestCleanup]
        public void Cleanup()
        {
            driver?.Quit();

            if (_webserverProcess != null)
            {
                StopServer();
            }
        }

        protected void StartDriver(string browserVersion = null)
        {
            ChromeOptions options = new ChromeOptions();
            if (browserVersion != null)
            {
                options.BrowserVersion = browserVersion;
                string userDataDir = System.IO.Path.Combine(System.IO.Path.GetTempPath(), System.IO.Path.GetRandomFileName());
                System.IO.Directory.CreateDirectory(userDataDir);
                options.AddArgument($"--user-data-dir={userDataDir}");
                options.AddArgument("--no-sandbox");
                options.AddArgument("--disable-dev-shm-usage");
            }
            driver = new ChromeDriver(options);
        }

        protected async Task StartServer()
        {
            if (_webserverProcess == null || _webserverProcess.HasExited)
            {
                _webserverProcess = new Process();
                _webserverProcess.StartInfo.FileName =
                    RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "java.exe" : "java";
                string port = GetFreeTcpPort().ToString();
                GridUrl = new Uri("http://localhost:" + port + "/wd/hub");
                _webserverProcess.StartInfo.Arguments = " -jar " + ServerJarName +
                                                        " standalone --port " + port +
                                                        " --selenium-manager true --enable-managed-downloads true";
                _webserverProcess.StartInfo.WorkingDirectory = _examplesDirectory;
                _webserverProcess.Start();
                await EnsureGridIsRunningAsync();
            }
        }

        private void StopServer()
        {
            if (_webserverProcess != null && !_webserverProcess.HasExited)
            {
                _webserverProcess.Kill();
                _webserverProcess.Dispose();
                _webserverProcess = null;
            }
        }

        private static int GetFreeTcpPort()
        {
            TcpListener l = new TcpListener(IPAddress.Loopback, 0);
            l.Start();
            int port = ((IPEndPoint)l.LocalEndpoint).Port;
            l.Stop();
            return port;
        }

        private async Task EnsureGridIsRunningAsync()
        {
            DateTime timeout = DateTime.Now.Add(TimeSpan.FromSeconds(30));
            bool isRunning = false;
            HttpClient client = new HttpClient();

            while (!isRunning && DateTime.Now < timeout)
            {
                try
                {
                    HttpResponseMessage response = await client.GetAsync(GridUrl + "/status");
                    if (response.IsSuccessStatusCode)
                    {
                        isRunning = true;
                    }
                    else
                    {
                        await Task.Delay(500);
                    }
                }
                catch (HttpRequestException)
                {
                    await Task.Delay(500);
                }
            }

            if (!isRunning)
            {
                throw new TimeoutException("Could not confirm the remote selenium server is running within 30 seconds");
            }
        }
    }
}

# frozen_string_literal: true

require 'spec_helper'

RSpec.describe 'Chrome' do
  describe 'Driver Options' do
    let(:chrome_location) { driver_finder && ENV.fetch('CHROME_BIN', nil) }

  it 'page load strategy normal' do
      options = Selenium::WebDriver::Options.chrome
      options.page_load_strategy = :normal

      driver = Selenium::WebDriver.for :chrome, options: options
      driver.get('https://www.google.com')
      driver.quit
  end

  it 'page load strategy eager' do
       options = Selenium::WebDriver::Options.chrome
       options.page_load_strategy = :eager

       driver = Selenium::WebDriver.for :chrome, options: options
       driver.get('https://www.google.com')
       driver.quit
  end

  it 'page load strategy none' do
      options = Selenium::WebDriver::Options.chrome
      options.page_load_strategy = :none

      driver = Selenium::WebDriver.for :chrome, options: options
      driver.get('https://www.google.com')
      driver.quit
  end
  end
end

const fs = require('fs');
const os = require('os');
const path = require('path');
const Chrome = require('selenium-webdriver/chrome');
const {Browser, Builder} = require("selenium-webdriver");
const {getBinaryPaths} = require("selenium-webdriver/common/driverFinder");

describe('Service Test', function () {
  let driver;
  let userDataDir;
  let service;
  let options;

  afterEach(async function () {
    if (driver) {
      await driver.quit();
      driver = null;
    }
    if (userDataDir) {
      fs.rmSync(userDataDir, { recursive: true, force: true });
      userDataDir = null;
    }
  });

  it('Default service', async function () {
    service = new Chrome.ServiceBuilder();
    driver = new Builder()
      .forBrowser(Browser.CHROME)
      .setChromeService(service)
      .build();
    await driver.get('https://www.selenium.dev/selenium/web/blank.html');
  });

  it('Set Driver Location', async function () {
    options = new Chrome.Options();
    options.setBrowserVersion("stable");
    let paths = getBinaryPaths(options);
    let driverPath = paths.driverPath;
    let browserPath = paths.browserPath;
    options.setChromeBinaryPath(browserPath);
    userDataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'chrome-profile-'));
    options.addArguments(`--user-data-dir=${userDataDir}`);
    options.addArguments('--no-sandbox');
    options.addArguments('--disable-dev-shm-usage');
    service = new Chrome.ServiceBuilder(driverPath);
    driver = new Builder()
      .forBrowser(Browser.CHROME)
      .setChromeOptions(options)
      .setChromeService(service)
      .build();
    await driver.get('https://www.selenium.dev/selenium/web/blank.html');
  });

  it('Set port', async function () {
    service = new Chrome.ServiceBuilder().setPort(1234);
    driver = new Builder()
      .forBrowser(Browser.CHROME)
      .setChromeService(service)
      .build();
    await driver.get('https://www.selenium.dev/selenium/web/blank.html');
  });
});

from selenium import webdriver


def test_page_load_strategy_normal():
    options = webdriver.ChromeOptions()

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

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


def test_page_load_strategy_eager():
    options = webdriver.ChromeOptions()

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

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


def test_page_load_strategy_none():
    options = webdriver.ChromeOptions()

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

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

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

namespace SeleniumDocs.GettingStarted;

public static class FirstScript
{
    public static void Main()
    {
        IWebDriver driver = new ChromeDriver();

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

        var title = driver.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;
            
        driver.Quit();
    }
}

# frozen_string_literal: true

require 'spec_helper'

RSpec.describe 'Chrome' do
  describe 'Driver Options' do
    let(:chrome_location) { driver_finder && ENV.fetch('CHROME_BIN', nil) }

  it 'page load strategy normal' do
      options = Selenium::WebDriver::Options.chrome
      options.page_load_strategy = :normal

      driver = Selenium::WebDriver.for :chrome, options: options
      driver.get('https://www.google.com')
      driver.quit
  end

  it 'page load strategy eager' do
       options = Selenium::WebDriver::Options.chrome
       options.page_load_strategy = :eager

       driver = Selenium::WebDriver.for :chrome, options: options
       driver.get('https://www.google.com')
       driver.quit
  end

  it 'page load strategy none' do
      options = Selenium::WebDriver::Options.chrome
      options.page_load_strategy = :none

      driver = Selenium::WebDriver.for :chrome, options: options
      driver.get('https://www.google.com')
      driver.quit
  end
  end
end

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

(async function firstTest() {
  let driver;
  
  try {
    driver = await new Builder().forBrowser(Browser.CHROME).build();
    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);
  } catch (e) {
    console.log(e)
  } finally {
    await driver.quit();
  }
}())

package dev.selenium.getting_started

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://www.selenium.dev/selenium/web/web-form.html")

        val title = driver.title
        assertEquals("Web form", title)

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

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

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

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

        driver.quit()
    }

}