1 - Trabajando con colores

En algunas ocasiones es posible que sea necesario querer validar el color de algo como parte de tus tests; el problema es que las definiciones de color en la web no son constantes. ¿No estaría bien que existiese una forma sencilla de comparar una representación de color HEX con una representación de color RGB, o una representación de color RGBA con una representación de color HSLA?

No te preocupes. Hay una solución para esto, la clase Color

Lo primero de todo, necesitaras importar la clase:

import org.openqa.selenium.support.Color;
  
from selenium.webdriver.support.color import Color
  
// No disponemos del ejemplo de código en C# aun - Ayudanos a ello abriendo un PR
  
include Selenium::WebDriver::Support
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
import org.openqa.selenium.support.Color

Ahora puedes empezar a crear objetos de la clase Color. Cada objeto necesita ser creado a partir de la representación de una cadena de texto de tu color.

Las representaciones de colores soportadas son:

private final Color HEX_COLOUR = Color.fromString("#2F7ED8");
private final Color RGB_COLOUR = Color.fromString("rgb(255, 255, 255)");
private final Color RGB_COLOUR = Color.fromString("rgb(40%, 20%, 40%)");
private final Color RGBA_COLOUR = Color.fromString("rgba(255, 255, 255, 0.5)");
private final Color RGBA_COLOUR = Color.fromString("rgba(40%, 20%, 40%, 0.5)");
private final Color HSL_COLOUR = Color.fromString("hsl(100, 0%, 50%)");
private final Color HSLA_COLOUR = Color.fromString("hsla(100, 0%, 50%, 0.5)");
  
HEX_COLOUR = Color.from_string('#2F7ED8')
RGB_COLOUR = Color.from_string('rgb(255, 255, 255)')
RGB_COLOUR = Color.from_string('rgb(40%, 20%, 40%)')
RGBA_COLOUR = Color.from_string('rgba(255, 255, 255, 0.5)')
RGBA_COLOUR = Color.from_string('rgba(40%, 20%, 40%, 0.5)')
HSL_COLOUR = Color.from_string('hsl(100, 0%, 50%)')
HSLA_COLOUR = Color.from_string('hsla(100, 0%, 50%, 0.5)')
  
// No disponemos del ejemplo de código en C# aun - Ayudanos a ello abriendo un PR
  
HEX_COLOUR = Color.from_string('#2F7ED8')
RGB_COLOUR = Color.from_string('rgb(255, 255, 255)')
RGB_COLOUR = Color.from_string('rgb(40%, 20%, 40%)')
RGBA_COLOUR = Color.from_string('rgba(255, 255, 255, 0.5)')
RGBA_COLOUR = Color.from_string('rgba(40%, 20%, 40%, 0.5)')
HSL_COLOUR = Color.from_string('hsl(100, 0%, 50%)')
HSLA_COLOUR = Color.from_string('hsla(100, 0%, 50%, 0.5)')
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
private val HEX_COLOUR = Color.fromString("#2F7ED8")
private val RGB_COLOUR = Color.fromString("rgb(255, 255, 255)")
private val RGB_COLOUR_PERCENT = Color.fromString("rgb(40%, 20%, 40%)")
private val RGBA_COLOUR = Color.fromString("rgba(255, 255, 255, 0.5)")
private val RGBA_COLOUR_PERCENT = Color.fromString("rgba(40%, 20%, 40%, 0.5)")
private val HSL_COLOUR = Color.fromString("hsl(100, 0%, 50%)")
private val HSLA_COLOUR = Color.fromString("hsla(100, 0%, 50%, 0.5)")
  

La clase Color también soporta todas las definiciones base de colores especificadas en http://www.w3.org/TR/css3-color/#html4.

private final Color BLACK = Color.fromString("black");
private final Color CHOCOLATE = Color.fromString("chocolate");
private final Color HOTPINK = Color.fromString("hotpink");
  
BLACK = Color.from_string('black')
CHOCOLATE = Color.from_string('chocolate')
HOTPINK = Color.from_string('hotpink')
  
// No disponemos del ejemplo de código en C# aun - Ayudanos a ello abriendo un PR
  
BLACK = Color.from_string('black')
CHOCOLATE = Color.from_string('chocolate')
HOTPINK = Color.from_string('hotpink')
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
private val BLACK = Color.fromString("black")
private val CHOCOLATE = Color.fromString("chocolate")
private val HOTPINK = Color.fromString("hotpink")
  

En muchas ocasiones los navegadores devolverán un valor de color de transparente si no se ha establecido color en el elemento. La clase Color también soporta esto:

private final Color TRANSPARENT = Color.fromString("transparent");
  
TRANSPARENT = Color.from_string('transparent')
  
// No disponemos del ejemplo de código en C# aun - Ayudanos a ello abriendo un PR
  
TRANSPARENT = Color.from_string('transparent')
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
private val TRANSPARENT = Color.fromString("transparent")
  

Ahora puedes consultar de forma segura un elemento para obtener su color/color de fondo sabiendo que cualquier respuesta sera correctamente parseada y convertida en un objeto Color valido.

Color loginButtonColour = Color.fromString(driver.findElement(By.id("login")).getCssValue("color"));

Color loginButtonBackgroundColour = Color.fromString(driver.findElement(By.id("login")).getCssValue("background-color"));
  
login_button_colour = Color.from_string(driver.find_element(By.ID,'login').value_of_css_property('color'))

login_button_background_colour = Color.from_string(driver.find_element(By.ID,'login').value_of_css_property('background-color'))
  
// No disponemos del ejemplo de código en C# aun - Ayudanos a ello abriendo un PR
  
login_button_colour = Color.from_string(driver.find_element(id: 'login').css_value('color'))

login_button_background_colour = Color.from_string(driver.find_element(id: 'login').css_value('background-color'))
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
val loginButtonColour = Color.fromString(driver.findElement(By.id("login")).getCssValue("color"))

val loginButtonBackgroundColour = Color.fromString(driver.findElement(By.id("login")).getCssValue("background-color"))
  

Puedes comparar objetos de Color directamente:

assert loginButtonBackgroundColour.equals(HOTPINK);
  
assert login_button_background_colour == HOTPINK
  
// No disponemos del ejemplo de código en C# aun - Ayudanos a ello abriendo un PR
  
assert(login_button_background_colour == HOTPINK)
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
assert(loginButtonBackgroundColour.equals(HOTPINK))
  

También puedes convertir un color en uno de los siguientes formatos y después realizar una validación estática:

assert loginButtonBackgroundColour.asHex().equals("#ff69b4");
assert loginButtonBackgroundColour.asRgba().equals("rgba(255, 105, 180, 1)");
assert loginButtonBackgroundColour.asRgb().equals("rgb(255, 105, 180)");
  
assert login_button_background_colour.hex == '#ff69b4'
assert login_button_background_colour.rgba == 'rgba(255, 105, 180, 1)'
assert login_button_background_colour.rgb == 'rgb(255, 105, 180)'
  
// No disponemos del ejemplo de código en C# aun - Ayudanos a ello abriendo un PR
  
assert(login_button_background_colour.hex == '#ff69b4')
assert(login_button_background_colour.rgba == 'rgba(255, 105, 180, 1)')
assert(login_button_background_colour.rgb == 'rgb(255, 105, 180)')
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
assert(loginButtonBackgroundColour.asHex().equals("#ff69b4"))
assert(loginButtonBackgroundColour.asRgba().equals("rgba(255, 105, 180, 1)"))
assert(loginButtonBackgroundColour.asRgb().equals("rgb(255, 105, 180)"))
  

Con todo esto los colores ya no serán un problema.

2 - Trabajando con elementos select

A la hora de seleccionar elementos puede ser necesario código repetitivo para poder ser automatizado. Para reducir esto y hacer tus test mas limpios, existe un clase Select en los paquetes de soporte de Selenium. Para usarla, necesitarás importarla de la siguiente forma:

import org.openqa.selenium.support.ui.Select;
  
from selenium.webdriver.support.select import Select
  
using OpenQA.Selenium.Support.UI
  
include Selenium::WebDriver::Support
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
import org.openqa.selenium.support.ui.Select
  

Una vez importado, ya podrás crear un objeto Select usando un WebElement que referencie a un elemento <select>.

WebElement selectElement = driver.findElement(By.id("selectElementID"));
Select selectObject = new Select(selectElement);
  
select_element = driver.find_element(By.ID,'selectElementID')
select_object = Select(select_element)
  
IWebElement selectElement = driver.FindElement(By.Id("selectElementID"));
var selectObject = new SelectElement(selectElement);
  
select_element = driver.find_element(id: 'selectElementID')
select_object = Select(select_element)
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
val selectElement = driver.findElement(By.id("selectElementID"))
val selectObject = new Select(selectElement)
  

El objeto Select te proporcionará una serie de comandos que te permitirán interactuar con los elementos <select>. Lo primero de todo, existen diferentes formas de seleccionar una opción de un elemento <select>.

<select>
 <option value=value1>Bread</option>
 <option value=value2 selected>Milk</option>
 <option value=value3>Cheese</option>
</select>

Existen tres formas de seleccionar la primera opción del ejemplo que se muestra arriba.

// Selecciona una <option> basándose en el indice interno del elemento <select>
selectObject.selectByIndex(1);

// Selecciona una <option> basándose en su atributo value
selectObject.selectByValue("value1");

// Selecciona una <option> basándose en el texto que muestra
selectObject.selectByVisibleText("Bread");
  
# Selecciona una <option> basándose en el indice interno del elemento <select>
select_object.select_by_index(1)

# Selecciona una <option> basándose en su atributo value
select_object.select_by_value('value1')

# Selecciona una <option> basándose en el texto que muestra
select_object.select_by_visible_text('Bread')
  
// Selecciona una <option> basándose en el indice interno del elemento <select>
selectObject.SelectByIndex(1);

// Selecciona una <option> basándose en su atributo value
selectObject.SelectByValue("value1");

// Selecciona una <option> basándose en el texto que muestra
selectObject.SelectByText("Bread");
  
# Selecciona una <option> basándose en el indice interno del elemento <select>
select_object.select_by(:index, 1)

# Selecciona una <option> basándose en su atributo value
select_object.select_by(:value, 'value1')

# Selecciona una <option> basándose en el texto que muestra
select_object.select_by(:text, 'Bread')
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
// Selecciona una <option> basándose en el indice interno del elemento <select>
selectObject.selectByIndex(1)

// Selecciona una <option> basándose en su atributo value
selectObject.selectByValue("value1")

// Selecciona una <option> basándose en el texto que muestra
selectObject.selectByVisibleText("Bread")
  

Puedes revisar que opciones están seleccionadas usando:

// Devuelve una Lista de <WebElements> con las opciones que han sido seleccionadas
List<WebElement> allSelectedOptions = selectObject.getAllSelectedOptions();

// Devuelve un WebElement que referencia a la primera opción seleccionada que se encontró en el DOM
WebElement firstSelectedOption = selectObject.getFirstSelectedOption();
  
# Devuelve una Lista de [WebElements] con las opciones que han sido seleccionadas
all_selected_options = select_object.all_selected_options

# Devuelve un WebElement que referencia a la primera opción seleccionada que se encontró en el DOM
first_selected_option = select_object.first_selected_option
  
// Return a List<WebElement> of options that have been selected
var allSelectedOptions = selectObject.AllSelectedOptions;

// Return a WebElement referencing the first selection option found by walking down the DOM
var firstSelectedOption = selectObject.AllSelectedOptions.FirstOrDefault();
  
# Devuelve un Array de <WebElements> con las opciones que han sido seleccionadas
all_selected_options = select_object.selected_options

# Devuelve un WebElement que referencia a la primera opción seleccionada que se encontró en el DOM
first_selected_option = select_object.first_selected_option
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
// Devuelve una Lista de <WebElements> con las opciones que han sido seleccionadas
val allSelectedOptions = selectObject.allSelectedOptions

// Devuelve un WebElement que referencia a la primera opción seleccionada que se encontró en el DOM
val firstSelectedOption = selectObject.firstSelectedOption
  

Tambien existe una forma de obtener que elementos <option> contiene un <select>:

// Devuelve una lista de <WebElements> que contiene las opciones de un elemento <select>
List<WebElement> allAvailableOptions = selectObject.getOptions();
  
# Devuelve una lista de [WebElements] que contiene las opciones de un elemento &lt;select&gt;
all_available_options = select_object.options
  
// Devuelve una IList de <IWebElements> que contiene las opciones de un elemento <select>
IList<IWebElement> allAvailableOptions = selectObject.Options;
  
# Devuelve un array de [WebElements] que contiene las opciones de un elemento &lt;select&gt;
all_available_options = select_object.options
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
// Devuelve una lista de <WebElements> que contiene las opciones de un elemento <select>
val allAvailableOptions = selectObject.options
  

A la hora de deseleccionar elementos dispones de cuatro opciones:

// Deseleccionar una <option> basándose en el indice interno de un elemento <select>
selectObject.deselectByIndex(1);

// Deseleccionar una <option> basándose en su atributo `value`
selectObject.deselectByValue("value1");

// Deseleccionar una <option> basándose en el texto que muestra
selectObject.deselectByVisibleText("Bread");

// Deseleccionar todos los elementos <option> que estan seleccionados
selectObject.deselectAll();
  
# Deseleccionar una <option> basándose en el indice interno de un elemento <select>
select_object.deselect_by_index(1)

# Deseleccionar una <option> basándose en su atributo `value`
select_object.deselect_by_value('value1')

# Deseleccionar una <option> basándose en el texto que muestra
select_object.deselect_by_visible_text('Bread')

# Deseleccionar todos los elementos <option> que estan seleccionados
select_object.deselect_all()
  
// Deseleccionar una <option> basándose en el indice interno de un elemento <select>
selectObject.DeselectByIndex(1);

// Deseleccionar una <option> basándose en su atributo `value`
selectObject.DeselectByValue("value1");

// Deseleccionar una <option> basándose en el texto que muestra
selectObject.DeselectByText("Bread");

// Deseleccionar todos los elementos <option> que estan seleccionados
selectObject.DeselectAll();
  
# Deseleccionar una <option> basándose en el indice interno de un elemento <select>
select_object.deselect_by(:index, 1)

# Deseleccionar una <option> basándose en su atributo `value`
select_object.deselect_by(:value, 'value1')

# Deseleccionar una <option> basándose en el texto que muestra
select_object.deselect_by(:text, 'Bread')

# Deseleccionar todos los elementos <option> que estan seleccionados
select_object.deselect_all
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
// Deseleccionar una <option> basándose en el indice interno de un elemento <select>
selectObject.deselectByIndex(1)

// Deseleccionar una <option> basándose en su atributo `value`
selectObject.deselectByValue("value1")

// Deseleccionar una <option> basándose en el texto que muestra
selectObject.deselectByVisibleText("Bread")

// Deseleccionar todos los elementos <option> que estan seleccionados
selectObject.deselectAll()
  

Finalmente, existen algunos elementos <select> que te permiten seleccionar mas de una opción. Puedes comprobar si tu elemento <select> es uno de estos usando:

Boolean doesThisAllowMultipleSelections = selectObject.isMultiple();
  
does_this_allow_multiple_selections = select_object.is_multiple
  
bool doesThisAllowMultipleSelections = selectObject.IsMultiple;
  
does_this_allow_multiple_selections = select_object.multiple?
  
// This feature is not implemented - Help us by sending a pr to implement this feature
  
val doesThisAllowMultipleSelections = selectObject.isMultiple
  

3 - Acciones del ratón en detalle

El ratón representa eventos del ratón. Las acciones del ratón son realizadas a través de una interfaz de bajo nivel la cual nos permite introducir acciones de dispositivos virtualizados al navegador web.

clickAndHold

Moverá el ratón al elemento y hará clic (sin soltar) en medio del elemento dado.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;

public class clickAndHold {
  public static void main(String[] args) {
    WebDriver driver = new ChromeDriver();
    try {
      // Navega a la URL
      driver.get("https://google.com");

      // Guarda el elemento web del botón 'Sign in'
      WebElement searchBtn = driver.findElement(By.linkText("Sign in"));
      Actions actionProvider = new Actions(driver);
      // Realiza la acción click-and-hold en el elemento
      actionProvider.clickAndHold(searchBtn).build().perform();
    } finally {
      driver.quit();
    }
  }
}
  
from selenium import webdriver
driver = webdriver.Chrome()

# Navega a la URL
driver.get("http://www.google.com")

# Guarda el elemento web del botón 'Sign in'
searchBtn = driver.find_element(By.LINK_TEXT, "Sign in")

# Realiza la acción click-and-hold en el elemento
webdriver.ActionChains(driver).click_and_hold(searchBtn).perform()
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Interactions;

namespace SeleniumApp
{
  public class ClickAndHold
  {
    public static void Main(string[] agrs)
    {
      IWebDriver driver = new ChromeDriver();
      try
      {
        // Navega a la URL
        driver.Navigate().GoToUrl("https://google.com");
        // Guarda el elemento web del botón 'Sign in'
        IWebElement searchBtn = driver.FindElement(By.LinkText("Sign in"));
        Actions actionProvider = new Actions(driver);
        // Realiza la acción click-and-hold en el elemento
        actionProvider.ClickAndHold(searchBtn).Build().Perform();
      }
      finally
      {
        driver.Quit();
      }
    }
  }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  # Navega a la URL
  driver.get 'https://www.google.com'
  # Guarda el elemento web del botón 'Sign in'
  sign_in = driver.find_element(link_text: 'Sign in')
  # Realiza la acción click-and-hold en el elemento
  driver.action.click_and_hold(sign_in).perform
ensure
  driver.quit
end
  
const {Builder, By} = require('selenium-webdriver');

(async function clickAndHold() {
  let driver = await new Builder().forBrowser('chrome').build();
  try {
    // Navega a la URL
    await driver.get('https://www.google.com');
    // Guarda el elemento web del botón 'Sign in'
    let searchBtn = driver.findElement(By.linkText("Sign in"));
    const actions = driver.actions({async: true});
    // Realiza la acción click-and-hold en el elemento
    await actions.move({origin:searchBtn}).press().perform();
  }
  finally {
    await driver.quit();
  }
})();
  
import org.openqa.selenium.By
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.interactions.Actions

fun main() {
    val driver =  ChromeDriver()
    try {
        // Navega a la URL
        driver.get("https://google.com")
        // Guarda el elemento web del botón 'Sign in'
        val searchBtn = driver.findElement(By.linkText("Sign in"))
        val actionProvider = Actions(driver)
        // Realiza la acción click-and-hold en el elemento
        actionProvider.clickAndHold(searchBtn).build().perform()
    } finally {
        driver.quit()
    }
}
  

contextClick

Este método en primer lugar realiza un movimiento del ratón a la localización del elemento y realiza un clic contextual (clic derecho) en el elemento dado.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;

public class contextClick {
  public static void main(String[] args) {
    WebDriver driver = new ChromeDriver();
    try {
      // Navega a la URL
      driver.get("https://google.com");

      // Guarda el elemento web del botón 'Sign in'
      WebElement searchBtn = driver.findElement(By.linkText("Sign in"));
      Actions actionProvider = new Actions(driver);
      // Realiza la acción context-click en el elemento
      actionProvider.contextClick(searchBtn).build().perform();
    } finally {
      driver.quit();
    }
  }
}
  
from selenium import webdriver
driver = webdriver.Chrome()

# Navega a la URL
driver.get("http://www.google.com")

# Guarda el elemento web del botón 'Sign in'
searchBtn = driver.find_element(By.LINK_TEXT, "Sign in")

# Realiza la acción context-click en el elemento
webdriver.ActionChains(driver).context_click(searchBtn).perform()
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Interactions;

namespace SeleniumApp
{
  public class ContextClick
  {
    public static void Main(string[] agrs)
    {
      IWebDriver driver = new ChromeDriver();
      try
      {
        // Navega a la URL
        driver.Navigate().GoToUrl("https://google.com");
        // Guarda el elemento web del botón 'Sign in'
        IWebElement searchBtn = driver.FindElement(By.LinkText("Sign in"));
        Actions actionProvider = new Actions(driver);
        // Realiza la acción context-click en el elemento
        actionProvider.ContextClick(searchBtn).Build().Perform();
      }
      finally
      {
        driver.Quit();
      }
    }
  }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  # Navega a la URL
  driver.get 'https://www.google.com'
  #  Guarda el elemento web del botón 'Sign in'
  sign_in = driver.find_element(link_text: 'Sign in')
  # Realiza la acción context-click en el elemento
  driver.action.context_click(sign_in).perform
ensure
  driver.quit
end
  
const {Builder, By} = require('selenium-webdriver');

(async function contextClick() {
  let driver = await new Builder().forBrowser('chrome').build();
  try {
    // Navega a la URL
    await driver.get('https://www.google.com');
    // Guarda el elemento web del botón 'Sign in'
    let searchBtn = driver.findElement(By.linkText("Sign in"));
    const actions = driver.actions({async: true});
    // Realiza la acción context-click en el elemento
    await actions.contextClick(searchBtn).perform();
  }
  finally {
    await driver.quit();
  }
})();
  
import org.openqa.selenium.By
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.interactions.Actions

fun main() {
    val driver =  ChromeDriver()
    try {
        // Navega a la URL
        driver.get("https://google.com")
        // Guarda el elemento web del botón 'Sign in'
        val searchBtn = driver.findElement(By.linkText("Sign in"))
        val actionProvider = Actions(driver)
        // Realiza la acción context-click en el elemento
        actionProvider.contextClick(searchBtn).build().perform()
    } finally {
        driver.quit()
    }
}
  

doubleClick

Moverá el ratón al elemento y realizará un clic doble en medio del elemento dado.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;

public class doubleClick {
  public static void main(String[] args) {
    WebDriver driver = new ChromeDriver();
    try {
      // Navega a la URL
      driver.get("https://google.com");

      // Guarda el elemento web del botón 'Sign in'
      WebElement searchBtn = driver.findElement(By.linkText("Sign in"));
      Actions actionProvider = new Actions(driver);
      // Realiza la acción double-click en el elemento
      actionProvider.doubleClick(searchBtn).build().perform();
    } finally {
      driver.quit();
    }
  }
}
  
from selenium import webdriver
driver = webdriver.Chrome()

# Navega a la URL
driver.get("http://www.google.com")

# Guarda el elemento web del botón 'Sign in'
searchBtn = driver.find_element(By.LINK_TEXT, "Sign in")

# Realiza la acción double-click en el elemento
webdriver.ActionChains(driver).double_click(searchBtn).perform()
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Interactions;

namespace SeleniumApp
{
  public class DoubleClick
  {
    public static void Main(string[] agrs)
    {
      IWebDriver driver = new ChromeDriver();
      try
      {
        // Navega a la URL
        driver.Navigate().GoToUrl("https://google.com");
        // Guarda el elemento web del botón 'Sign in'
        IWebElement searchBtn = driver.FindElement(By.LinkText("Sign in"));
        Actions actionProvider = new Actions(driver);
        // Realiza la acción double-click en el elemento
        actionProvider.DoubleClick(searchBtn).Build().Perform();
      }
      finally
      {
        driver.Quit();
      }
    }
  }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  # Navega a la URL
  driver.get 'https://www.google.com'
  # Guarda el elemento web del botón 'Sign in'
  sign_in = driver.find_element(link_text: 'Sign in')
  # Realiza la acción double-click en el elemento
  driver.action.double_click(sign_in).perform
ensure
  driver.quit
end
  
const {Builder, By} = require('selenium-webdriver');

(async function doubleClick() {
  let driver = await new Builder().forBrowser('chrome').build();
  try {
    // Navega a la URL
    await driver.get('https://www.google.com');
    // Guarda el elemento web del botón 'Sign in'
    let searchBtn = driver.findElement(By.linkText("Sign in"));
    const actions = driver.actions({async: true});
    // Realiza la acción double-click en el elemento
    await actions.doubleClick(searchBtn).perform();
  }
  finally {
    await driver.quit();
  }
})();
  
import org.openqa.selenium.By
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.interactions.Actions

fun main() {
    val driver =  ChromeDriver()
    try {
        // Navega a la URL
        driver.get("https://google.com")
        // Guarda el elemento web del botón 'Sign in'
        val searchBtn = driver.findElement(By.linkText("Sign in"))
        val actionProvider = Actions(driver)
        // Realiza la acción double-click en el elemento
        actionProvider.doubleClick(searchBtn).build().perform()
    } finally {
        driver.quit()
    }
}
  

moveToElement

Este método mueve el ratón en medio del elemento dado. El elemento ademas es desplazado hacia la vista al realizar la acción.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;

public class moveToElement {
  public static void main(String[] args) {
    WebDriver driver = new ChromeDriver();
    try {
      // Navega a la URL
      driver.get("https://google.com");

      // Guarda el elemento web del enlace 'Gmail'
      WebElement gmailLink = driver.findElement(By.linkText("Gmail"));
      Actions actionProvider = new Actions(driver);
      // Realiza la acción move hacia el elemento
      actionProvider.moveToElement(gmailLink).build().perform();
    } finally {
      driver.quit();
    }
  }
}
  
from selenium import webdriver
driver = webdriver.Chrome()

# Navega a la URL
driver.get("http://www.google.com")

# Guarda el elemento web del enlace 'Gmail'
gmailLink = driver.find_element(By.LINK_TEXT, "Gmail")

# Realiza la acción move hacia el elemento
webdriver.ActionChains(driver).move_to_element(gmailLink).perform()
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Interactions;

namespace SeleniumApp
{
  public class MoveToElement
  {
    public static void Main(string[] agrs)
    {
      IWebDriver driver = new ChromeDriver();
      try
      {
        // Navega a la URL
        driver.Navigate().GoToUrl("https://google.com");
        // Guarda el elemento web del enlace 'Gmail'
        IWebElement gmailLink = driver.FindElement(By.LinkText("Gmail"));
        Actions actionProvider = new Actions(driver);
        // Realiza la acción move hacia el elemento
        actionProvider.MoveToElement(gmailLink).Build().Perform();
      }
      finally
      {
        driver.Quit();
      }
    }
  }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  # Navega a la URL
  driver.get 'https://www.google.com'
  # Guarda el elemento web del enlace 'Gmail'
  gmail_link = driver.find_element(link_text: 'Gmail')
  # Realiza la acción move hacia el elemento
  driver.action.move_to(gmail_link).perform
ensure
  driver.quit
end
  
const {Builder, By} = require('selenium-webdriver');

(async function moveToElement() {
  let driver = await new Builder().forBrowser('chrome').build();
  try {
    // Navega a la URL
    await driver.get('https://www.google.com');
    // Guarda el elemento web del enlace 'Gmail'
    let gmailLink = driver.findElement(By.linkText("Gmail"));
    const actions = driver.actions({async: true});
    // Realiza la acción move hacia el elemento
    await actions.move({origin:gmailLink}).perform();
  }
  finally {
    await driver.quit();
  }
})();
  
import org.openqa.selenium.By
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.interactions.Actions

fun main() {
    val driver =  ChromeDriver()
    try {
        // Navega a la URL
        driver.get("https://google.com")
        // Guarda el elemento web del enlace 'Gmail'
        val gmailLink = driver.findElement(By.linkText("Gmail"))
        val actionProvider = Actions(driver)
        // Realiza la acción move hacia el elemento
        actionProvider.moveToElement(gmailLink).build().perform()
    } finally {
        driver.quit()
    }
}
  

moveByOffset:

Este método mueve el ratón desde su posición actual (o desde 0,0) hasta un desplazamiento dado. Si las coordenadas están fuera de la vista de la ventana, entonces el ratón terminará fuera de la ventana del navegador.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;

public class moveByOffset {
  public static void main(String[] args) {
    WebDriver driver = new ChromeDriver();
    try {
      // Navega a la URL
      driver.get("https://google.com");

      // Guarda el elemento web del enlace 'Gmail'
      WebElement gmailLink = driver.findElement(By.linkText("Gmail"));
      // Captura el desplazamiento de las posiciones x e y del elemento
      int xOffset = gmailLink.getRect().getX();
      int yOffset = gmailLink.getRect().getY();
      Actions actionProvider = new Actions(driver);
      // Realiza la acción move hacia la posición del desplazamiento
      actionProvider.moveByOffset(xOffset, yOffset).build().perform();
    } finally {
      driver.quit();
    }
  }
}
  
from selenium import webdriver
driver = webdriver.Chrome()

# Navega a la URL
driver.get("http://www.google.com")

# Guarda el elemento web del enlace 'Gmail'
gmailLink = driver.find_element(By.LINK_TEXT, "Gmail")
# Captura el desplazamiento de las posiciones x e y del elemento
xOffset = 100
yOffset = 100
# Realiza la acción move hacia la posición del desplazamiento
webdriver.ActionChains(driver).move_by_offset(xOffset,yOffset).perform()
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Interactions;

namespace SeleniumApp
{
  public class MoveByOffset
  {
    public static void Main(string[] agrs)
    {
      IWebDriver driver = new ChromeDriver();
      try
      {
        // Navega a la URL
        driver.Navigate().GoToUrl("https://google.com");
        // Guarda el elemento web del enlace 'Gmail'
        IWebElement gmailLink = driver.FindElement(By.LinkText("Gmail"));
        // Captura el desplazamiento de las posiciones x e y del elemento
        int xOffset = 100;
        int yOffset = 100;
        Actions actionProvider = new Actions(driver);
        // Realiza la acción move hacia la posición del desplazamiento
        actionProvider.MoveByOffset(xOffset, yOffset).Build().Perform();
      }
      finally
      {
        driver.Quit();
      }
    }
  }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  # Navega a la URL
  driver.get 'https://www.google.com'
  # Guarda el elemento web del enlace 'Gmail'
  gmail_link = driver.find_element(link_text: 'Gmail')
  # Captura el desplazamiento de las posiciones x e y del elemento
  x_offset = gmail_link.rect.x
  y_offset = gmail_link.rect.y
  # Realiza la acción move hacia la posición del desplazamiento
  driver.action.move_to_location(x_offset, y_offset).perform
ensure
  driver.quit
end
  
const {Builder, By} = require('selenium-webdriver');

(async function moveByOffset() {
  let driver = await new Builder().forBrowser('chrome').build();
  try {
    // Navega a la URL
    await driver.get('https://www.google.com');
    // Guarda el elemento web del enlace 'Gmail'
    let gmailLink = driver.findElement(By.linkText("Gmail"));
    // Captura el desplazamiento de las posiciones x e y del elemento
    let offset = await gmailLink.getRect();
    let x = await offset.x;
    let y = await offset.y;
    const actions = driver.actions({async: true});
    // Realiza la acción move hacia la posición del desplazamiento
    await actions.move({x:parseInt(x),y:parseInt(y)}).pause(3000).perform();
  }
  finally {
    await driver.quit();
  }
})();
  
import org.openqa.selenium.By
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.interactions.Actions

fun main() {
    val driver =  ChromeDriver()
    try {
        // Navega a la URL
        driver.get("https://google.com")
        // Guarda el elemento web del enlace 'Gmail'
        val gmailLink = driver.findElement(By.linkText("Gmail"))
        // Captura el desplazamiento de las posiciones x e y del elemento
        val xOffset = gmailLink.rect.getX()
        val yOffset = gmailLink.rect.getY()
        val actionProvider = Actions(driver)
        // Realiza la acción move hacia la posición del desplazamiento
        actionProvider.moveByOffset(xOffset, yOffset).build().perform()
    } finally {
        driver.quit()
    }
}
  

dragAndDrop

Este método en primer lugar realiza una acción click-and-hold en el elemento de origen, después lo mueve a la localización del elemento de destino y por ultimo suelta el clic.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;

public class dragAndDrop {
  public static void main(String[] args) {
    WebDriver driver = new ChromeDriver();
    try {
      // Navega a la URL
      driver.get("https://crossbrowsertesting.github.io/drag-and-drop");
      // Guarda 'sourceEle' como elemento de origen
      WebElement sourceEle = driver.findElement(By.id("draggable"));
      // Guarda 'targetEle' como elemento de destino
      WebElement targetEle = driver.findElement(By.id("droppable"));
      Actions actionProvider = new Actions(driver);
      // Realiza la acción dragAndDrop desde el origen hacia el destino
      actionProvider.dragAndDrop(sourceEle, targetEle).build().perform();
    } finally {
      driver.quit();
    }
  }
}
  
from selenium import webdriver
driver = webdriver.Chrome()

# Navega a la URL
driver.get("https://crossbrowsertesting.github.io/drag-and-drop")

# Guarda 'sourceEle' como elemento de origen
sourceEle = driver.find_element(By.ID, "draggable")
# Guarda 'targetEle' como elemento de destino
targetEle  = driver.find_element(By.ID, "droppable")
# Realiza la acción dragAndDrop desde el origen hacia el destino
webdriver.ActionChains(driver).drag_and_drop(sourceEle,targetEle).perform()
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Interactions;

namespace SeleniumApp
{
  public class DragAndDrop
  {
    public static void Main(string[] agrs)
    {
      IWebDriver driver = new ChromeDriver();
      try
      {
        // Navega a la URL
        driver.Navigate().GoToUrl("https://crossbrowsertesting.github.io/drag-and-drop");
        // Guarda 'sourceEle' como elemento de origen
        IWebElement sourceEle = driver.FindElement(By.Id("draggable"));
        // Guarda 'targetEle' como elemento de destino
        IWebElement targetEle = driver.FindElement(By.Id("droppable"));
        Actions actionProvider = new Actions(driver);
        // Realiza la acción dragAndDrop desde el origen hacia el destino
        actionProvider.DragAndDrop(sourceEle, targetEle).Build().Perform();
      }
      finally
      {
          driver.Quit();
      }
    }
  }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  # Navega a la URL
  driver.get 'https://crossbrowsertesting.github.io/drag-and-drop'
  # Guarda 'source_ele' como elemento de origen
  source_ele = driver.find_element(id: 'draggable')
  # Guarda 'target_ele' como elemento de destino
  target_ele = driver.find_element(id: 'droppable')
  # Realiza la acción dragAndDrop desde el origen hacia el destino
  driver.action.drag_and_drop(source_ele, target_ele).perform
ensure
  driver.quit
end
  
const {Builder, By} = require('selenium-webdriver');

(async function dragAndDrop() {
  let driver = await new Builder().forBrowser('chrome').build();
  try {
    // Navega a la URL
    await driver.get('https://crossbrowsertesting.github.io/drag-and-drop');
    // Guarda 'sourceEle' como elemento de origen
    let sourceEle = driver.findElement(By.id("draggable"));
    // Guarda 'targetEle' como elemento de destino
    let targetEle = driver.findElement(By.id("droppable"));
    const actions = driver.actions({async: true});
    // Realiza la acción dragAndDrop desde el origen hacia el destino
    await actions.dragAndDrop(sourceEle, targetEle).perform();
  }
  finally {
    await driver.quit();
  }
})();
  
import org.openqa.selenium.By
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.interactions.Actions

fun main() {
    val driver =  ChromeDriver()
    try {
        // Navega a la URL
        driver.get("https://crossbrowsertesting.github.io/drag-and-drop")
        // Guarda 'sourceEle' como elemento de origen
        val sourceEle = driver.findElement(By.id("draggable"))
        // Guarda 'targetEle' como elemento de destino
        val targetEle = driver.findElement(By.id("droppable"))
        val actionProvider = Actions(driver)
        // Realiza la acción dragAndDrop desde el origen hacia el destino
        actionProvider.dragAndDrop(sourceEle, targetEle).build().perform()
    } finally {
        driver.quit()
    }
}
  

dragAndDropBy

Este metodo en primer lugar realiza un click-and-hold en el elemento origen, mueve el ratón al desplacamiento dado y luego suelta el raton.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;

public class dragAndDropBy {
  public static void main(String[] args) {
    WebDriver driver = new ChromeDriver();
    try {
      // Navega a la URL
      driver.get("https://crossbrowsertesting.github.io/drag-and-drop");
      // Guarda 'sourceEle' como elemento de origen
      WebElement sourceEle = driver.findElement(By.id("draggable"));
      // Guarda 'targetEle' como elemento de destino y obtiene las coordenadas
      WebElement targetEle = driver.findElement(By.id("droppable"));
      int targetEleXOffset = targetEle.getLocation().getX();
      int targetEleYOffset = targetEle.getLocation().getY();
      Actions actionProvider = new Actions(driver);
      // Realiza la acción de  dragAndDropBy hacia el desplazamiento destino
      actionProvider.dragAndDropBy(sourceEle, targetEleXOffset, targetEleYOffset).build().perform();
    } finally {
      driver.quit();
    }
  }
}
  
from selenium import webdriver
driver = webdriver.Chrome()

# Navega a la URL
driver.get("https://crossbrowsertesting.github.io/drag-and-drop")

# Guarda 'sourceEle' como elemento de origen
sourceEle = driver.find_element(By.ID, "draggable")
# Guarda 'targetEle' como elemento de destino y obtiene las coordenadas
targetEle  = driver.find_element(By.ID, "droppable")
targetEleXOffset = targetEle.location.get("x")
targetEleYOffset = targetEle.location.get("y")

# Realiza la acción de  dragAndDropBy hacia el desplazamiento destino
webdriver.ActionChains(driver).drag_and_drop_by_offset(sourceEle, targetEleXOffset, targetEleYOffset).perform()
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Interactions;

namespace SeleniumApp
{
  public class DragAndDropToOffset
  {
    public static void Main(string[] agrs)
    {
      IWebDriver driver = new ChromeDriver();
      try
      {
        // Navega a la URL
        driver.Navigate().GoToUrl("https://crossbrowsertesting.github.io/drag-and-drop");
        // Guarda 'sourceEle' como elemento de origen
        IWebElement sourceEle = driver.FindElement(By.Id("draggable"));
        // Guarda 'targetEle' como elemento de destino y obtiene las coordenadas
        IWebElement targetEle = driver.FindElement(By.Id("droppable"));
        int targetEleXOffset = targetEle.Location.X;
        int targetEleYOffset = targetEle.Location.Y;
        Actions actionProvider = new Actions(driver);
        // Realiza la acción de  dragAndDropBy hacia el desplazamiento destino
        actionProvider.DragAndDropToOffset(sourceEle, targetEleXOffset, targetEleYOffset).Build().Perform();
      }
      finally
      {
        driver.Quit();
      }
    }
  }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  # Navega a la URL
  driver.get 'https://crossbrowsertesting.github.io/drag-and-drop'
  # Guarda 'source_ele' como elemento de origen
  source_ele = driver.find_element(id: 'draggable')
  target_ele = driver.find_element(id: 'droppable')
  # Guarda 'target_ele' como elemento de destino y obtiene las coordenadas
  x_offset = target_ele.rect.x
  y_offset = target_ele.rect.y
  # Realiza la acción de  dragAndDropBy hacia el desplazamiento destino
  driver.action.drag_and_drop_by(source_ele, x_offset, y_offset).perform
ensure
  driver.quit
end
  
const {Builder, By} = require('selenium-webdriver');

(async function dragAndDropBy() {
  let driver = await new Builder().forBrowser('chrome').build();
  try {
    // Navega a la URL
    await driver.get('https://crossbrowsertesting.github.io/drag-and-drop');
    // Guarda 'sourceEle' como elemento de origen
    let sourceEle = driver.findElement(By.id("draggable"));
    // Guarda 'targetEle' como elemento de destino y obtiene las coordenadas
    let targetEle = driver.findElement(By.id("droppable"));
    let offset = await targetEle.getRect();
    let x = await offset.x;
    let y = await offset.y;
    const actions = driver.actions({async: true});
    // Realiza la acción de  dragAndDropBy hacia el desplazamiento destino
    await actions.dragAndDrop(sourceEle, {x:parseInt(x), y:parseInt(y)}).perform();
  }
  finally {
    await driver.quit();
  }
})();
  
import org.openqa.selenium.By
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.interactions.Actions

fun main() {
    val driver =  ChromeDriver()
    try {
        // Navega a la URL
        driver.get("https://crossbrowsertesting.github.io/drag-and-drop")
        // Guarda 'sourceEle' como elemento de origen
        val sourceEle = driver.findElement(By.id("draggable"))
        // Guarda 'targetEle' como elemento de destino y obtiene las coordenadas
        val targetEle = driver.findElement(By.id("droppable"))
        val targetEleXOffset = targetEle.location.getX()
        val targetEleYOffset = targetEle.location.getY()
        val actionProvider = Actions(driver)
        // Realiza la acción de  dragAndDropBy hacia el desplazamiento destino
        actionProvider.dragAndDropBy(sourceEle, targetEleXOffset, targetEleYOffset).build().perform()
    } finally {
        driver.quit()
    }
}
  

release

Esta acción suelta el botón izquierdo del ratón. Si se le pasa un WebElement, soltará el botón izquierdo del ratón en el elemento dado.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;

public class release {
  public static void main(String[] args) {
    WebDriver driver = new ChromeDriver();
    try {
      // Navega a la URL
      driver.get("https://crossbrowsertesting.github.io/drag-and-drop");
      // Guarda 'sourceEle' como elemento de origen
      WebElement sourceEle = driver.findElement(By.id("draggable"));
      // Guarda 'targetEle' como elemento de destino
      WebElement targetEle = driver.findElement(By.id("droppable"));
      Actions actionProvider = new Actions(driver);
      actionProvider.clickAndHold(sourceEle).moveToElement(targetEle).build().perform();
      // Realiza la acción release
      actionProvider.release().build().perform();
    } finally {
      driver.quit();
    }
  }
}
  
from selenium import webdriver
driver = webdriver.Chrome()

# Navega a la URL
driver.get("https://crossbrowsertesting.github.io/drag-and-drop")

# Guarda 'sourceEle' como elemento de origen
sourceEle = driver.find_element(By.ID, "draggable")
# Guarda 'targetEle' como elemento de destino
targetEle  = driver.find_element(By.ID, "droppable")
webdriver.ActionChains(driver).click_and_hold(sourceEle).move_to_element(targetEle).perform()
# Realiza la acción release
webdriver.ActionChains(driver).release().perform()
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Interactions;

namespace SeleniumApp
{
  public class Release
  {
    public static void Main(string[] agrs)
    {
      IWebDriver driver = new ChromeDriver();
      try
      {
        // Navega a la URL
        driver.Navigate().GoToUrl("https://crossbrowsertesting.github.io/drag-and-drop");
        // Guarda 'sourceEle' como elemento de origen
        IWebElement sourceEle = driver.FindElement(By.Id("draggable"));
        // Guarda 'targetEle' como elemento de destino
        IWebElement targetEle = driver.FindElement(By.Id("droppable"));
        Actions actionProvider = new Actions(driver);
        actionProvider.ClickAndHold(sourceEle).MoveToElement(targetEle).Build().Perform();
        // Realiza la acción release       
        actionProvider.Release().Build().Perform();
      }
      finally
      {
        driver.Quit();
      }
    }
  }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  # Navega a la URL
  driver.get 'https://crossbrowsertesting.github.io/drag-and-drop'
  source_ele = driver.find_element(id: 'draggable')
  target_ele = driver.find_element(id: 'droppable')
  driver.action.click_and_hold(source_ele).move_to(target_ele).perform
  # Realiza la acción release
  driver.action.release.perform
ensure
  driver.quit
end
  
const {Builder, By} = require('selenium-webdriver');

(async function release() {
  let driver = await new Builder().forBrowser('chrome').build();
  try {
    // Navega a la URL
    await driver.get('https://crossbrowsertesting.github.io/drag-and-drop');
    // Guarda 'sourceEle' como elemento de origen
    let sourceEle = driver.findElement(By.id("draggable"));
    // Guarda 'targetEle' como elemento de destino
    let targetEle = driver.findElement(By.id("droppable"));
    const actions = driver.actions({async: true});
    await actions.move({origin:sourceEle}).press().perform();
    // Realiza la acción release
    await actions.move({origin:targetEle}).release().perform();
  }
  finally {
    await driver.quit();
  }
})();
  
import org.openqa.selenium.By
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.interactions.Actions

fun main() {
    val driver =  ChromeDriver()
    try {
        // Navega a la URL
        driver.get("https://crossbrowsertesting.github.io/drag-and-drop")
        // Guarda 'sourceEle' como elemento de origen
        val sourceEle = driver.findElement(By.id("draggable"))
        //Guarda 'targetEle' como elemento de destino
        val targetEle = driver.findElement(By.id("droppable"))
        val actionProvider = Actions(driver)
        actionProvider.clickAndHold(sourceEle).moveToElement(targetEle).build().perform()
        // Realiza la acción release
        actionProvider.release().build().perform()
    } finally {
        driver.quit()
    }
}
  

4 - Trabajando con las cookies

Una cookie es una pequeña pieza de datos que es enviada desde el sitio web y es almacenada en el ordenador. Las cookies son usadas principalmente para reconocer al usuario y cargar la información almacenada.

El API de WebDriver proporciona una forma de interactuar con las cookies a través de métodos incorporados como:

Este método es usado para añadir una cookie al contexto actual del navegador. Este método solo acepta un conjunto de objetos JSON serializables definidos. En este enlace esta la lista de claves valor JSON que son aceptadas.

Lo primero de todo, necesitas estar en el dominio para el que la cookie es valida. Si intentas añadir un conjunto de cookies preestablecidas antes de empezar a interactuar con el sitio web y la pagina de inicio es muy pesada o tarda demasiado en cargar una alternativa es encontrar una pagina mas pequeña en el sitio (típicamente la pagina del error 404 es liviana ej. http://example.com/some404page)

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

public class addCookie {
    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        try {
            driver.get("http://www.example.com");

            // Añade una cookie al contexto actual del navegador
            driver.manage().addCookie(new Cookie("key", "value"));
        } finally {
            driver.quit();
        }
    }
}
  
from selenium import webdriver

driver = webdriver.Chrome()

driver.get("http://www.example.com")

# Añade una cookie al contexto actual del navegador
driver.add_cookie({"name": "key", "value": "value"})
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace AddCookie {
 class AddCookie {
  public static void Main(string[] args) {
   IWebDriver driver = new ChromeDriver();
   try {
    // Navega a la URL
    driver.Navigate().GoToUrl("https://example.com");

    // Añade una cookie al contexto actual del navegador
    driver.Manage().Cookies.AddCookie(new Cookie("key", "value"));
   } finally {
    driver.Quit();
   }
  }
 }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  driver.get 'https://www.example.com'
  
  # Añade una cookie al contexto actual del navegador
  driver.manage.add_cookie(name: "key", value: "value")
ensure
  driver.quit
end
  
const {Builder} = require('selenium-webdriver');
(async function example() {
    let driver = new Builder()
        .forBrowser('chrome')
        .build();

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

    // Añade una cookie al contexto actual del navegador
    await driver.manage().addCookie({name:'key', value: 'value'});
})();
  
import org.openqa.selenium.Cookie
import org.openqa.selenium.chrome.ChromeDriver

fun main() {
    val driver = ChromeDriver()
    try {
        driver.get("https://example.com")

        // Añade una cookie al contexto actual del navegador
        driver.manage().addCookie(Cookie("key", "value"))
    } finally {
        driver.quit()
    }
} 
  

Devuelve la información de la cookie serializada que concuerda con el nombre de la cookie entre todas las cookies asociadas.

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

public class getCookieNamed {
    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        try {
            driver.get("http://www.example.com");
            driver.manage().addCookie(new Cookie("foo", "bar"));

            // Obtiene los detalles de la cookie con el nombre 'foo'
            Cookie cookie1 = driver.manage().getCookieNamed("foo");
            System.out.println(cookie1);
        } finally {
            driver.quit();
        }
    }
}
  
from selenium import webdriver

driver = webdriver.Chrome()

# Navega a la URL
driver.get("http://www.example.com")

# Añade una cookie al contexto actual del navegador
driver.add_cookie({"name": "foo", "value": "bar"})

# Obtiene los detalles de la cookie con el nombre 'foo'
print(driver.get_cookie("foo"))
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace GetCookieNamed {
 class GetCookieNamed {
  public static void Main(string[] args) {
   IWebDriver driver = new ChromeDriver();
   try {
    // Navega a la URL
    driver.Navigate().GoToUrl("https://example.com");
    driver.Manage().Cookies.AddCookie(new Cookie("foo", "bar"));

    // Obtiene los detalles de la cookie con el nombre 'foo'
    var cookie = driver.Manage().Cookies.GetCookieNamed("foo");
    System.Console.WriteLine(cookie);
   } finally {
    driver.Quit();
   }
  }
 }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  driver.get 'https://www.example.com'
  driver.manage.add_cookie(name: "foo", value: "bar")

  # Obtiene los detalles de la cookie con el nombre 'foo'
  puts driver.manage.cookie_named('foo')
ensure
  driver.quit
end
  
const {Builder} = require('selenium-webdriver');
(async function example() {
    let driver = new Builder()
        .forBrowser('chrome')
        .build();

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

    // Añade una cookie en el dominio actual
    await driver.manage().addCookie({name:'foo', value: 'bar'});

    // Obtiene los detalles de la cookie con el nombre 'foo' 
    driver.manage().getCookie('foo').then(function (cookie) {
        console.log('cookie details => ', cookie);
    });
})();
  
import org.openqa.selenium.Cookie
import org.openqa.selenium.chrome.ChromeDriver

fun main() {
    val driver = ChromeDriver()
    try {
        driver.get("https://example.com")
        driver.manage().addCookie(Cookie("foo", "bar"))

        // Obtiene los detalles de la cookie con el nombre 'foo'
        val cookie = driver.manage().getCookieNamed("foo")
        println(cookie)
    } finally {
        driver.quit()
    }
}  
  

Obtener todas las cookies

Devuelve la información serializada de las cookies de manera satisfactoria para el contexto actual del navegador. Si el navegador no esta disponible devolverá un error.

import org.openqa.selenium.*;
import org.openqa.selenium.chrome.ChromeDriver;
import java.util.Set;

public class getAllCookies {
    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        try {
            driver.get("http://www.example.com");
            // Añade varias cookies
            driver.manage().addCookie(new Cookie("test1", "cookie1"));
            driver.manage().addCookie(new Cookie("test2", "cookie2"));

            // Obtiene todas las cookies disponibles
            Set<Cookie> cookies = driver.manage().getCookies();
            System.out.println(cookies);
        } finally {
            driver.quit();
        }
    }
}
  
from selenium import webdriver

driver = webdriver.Chrome()

# Navega a la URL
driver.get("http://www.example.com")

driver.add_cookie({"name": "test1", "value": "cookie1"})
driver.add_cookie({"name": "test2", "value": "cookie2"})

# Obtiene todas las cookies disponibles
print(driver.get_cookies())
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace GetAllCookies {
 class GetAllCookies {
  public static void Main(string[] args) {
   IWebDriver driver = new ChromeDriver();
   try {
    // Navega a la URL
    driver.Navigate().GoToUrl("https://example.com");
    driver.Manage().Cookies.AddCookie(new Cookie("test1", "cookie1"));
    driver.Manage().Cookies.AddCookie(new Cookie("test2", "cookie2"));

    // Obtiene todas las cookies disponibles
    var cookies = driver.Manage().Cookies.AllCookies;
   } finally {
    driver.Quit();
   }
  }
 }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  driver.get 'https://www.example.com'
  driver.manage.add_cookie(name: "test1", value: "cookie1")
  driver.manage.add_cookie(name: "test2", value: "cookie2")

  # Obtiene todas las cookies disponibles
  puts driver.manage.all_cookies
ensure
  driver.quit
end
  
const {Builder} = require('selenium-webdriver');
(async function example() {
    let driver = new Builder()
        .forBrowser('chrome')
        .build();

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

    // Añade varias cookies
    await driver.manage().addCookie({name:'test1', value:'cookie1'});
    await driver.manage().addCookie({name:'test2', value:'cookie2'});

    // Obtiene todas las cookies disponibles
    driver.manage().getCookies().then(function (cookies) {
        console.log('cookie details => ', cookies);
    });
})();
  
import org.openqa.selenium.Cookie
import org.openqa.selenium.chrome.ChromeDriver

fun main() {
    val driver = ChromeDriver()
    try {
        driver.get("https://example.com")
        driver.manage().addCookie(Cookie("test1", "cookie1"))
        driver.manage().addCookie(Cookie("test2", "cookie2"))

        // Obtiene todas las cookies disponibles
        val cookies = driver.manage().cookies
        println(cookies)
    } finally {
        driver.quit()
    }
} 
  

Borra la información de la cookie que coincida con el nombre de la cookie proporcionado.

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

public class deleteCookie {
    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        try {
            driver.get("http://www.example.com");
            driver.manage().addCookie(new Cookie("test1", "cookie1"));
            Cookie cookie1 = new Cookie("test2", "cookie2");
            driver.manage().addCookie(cookie1);

            // Borra la cookie con el nombre 'test1'
            driver.manage().deleteCookieNamed("test1");

            /*
             Selenium Java tambien proporciona una forma de borrar cookies
             pasando un objeto cookie del contexto actual del navegador.
             */
            driver.manage().deleteCookie(cookie1);
        } finally {
            driver.quit();
        }
    }
}
  
from selenium import webdriver
driver = webdriver.Chrome()

# Navega a la URL
driver.get("http://www.example.com")
driver.add_cookie({"name": "test1", "value": "cookie1"})
driver.add_cookie({"name": "test2", "value": "cookie2"})

# Borra la cookie con el nombre 'test1'
driver.delete_cookie("test1")
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace DeleteCookie {
 class DeleteCookie {
  public static void Main(string[] args) {
   IWebDriver driver = new ChromeDriver();
   try {
    // Navega a la URL
    driver.Navigate().GoToUrl("https://example.com");
    driver.Manage().Cookies.AddCookie(new Cookie("test1", "cookie1"));
    var cookie = new Cookie("test2", "cookie2");
    driver.Manage().Cookies.AddCookie(cookie);

    // Borra la cookie con el nombre 'test1'
    driver.Manage().Cookies.DeleteCookieNamed("test1");

    // Selenium .Net tambien proporciona una forma de borrar cookies
    // pasando un objeto cookie del contexto actual del navegador.
    driver.Manage().Cookies.DeleteCookie(cookie);
   } finally {
    driver.Quit();
   }
  }
 }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  driver.get 'https://www.example.com'
  driver.manage.add_cookie(name: "test1", value: "cookie1")
  driver.manage.add_cookie(name: "test2", value: "cookie2")

  # Borra la cookie con el nombre 'test1'
  driver.manage.delete_cookie('test1')
ensure
  driver.quit
end
  
const {Builder} = require('selenium-webdriver');
(async function example() {
    let driver = new Builder()
        .forBrowser('chrome')
        .build();

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

    // Añade varias cookies
    await driver.manage().addCookie({name:'test1', value:'cookie1'});
    await driver.manage().addCookie({name:'test2', value:'cookie2'});

    // Borra la cookie con el nombre 'test1'
    await driver.manage().deleteCookie('test1');
    
    // Muestra todas las cookies disponibles
    driver.manage().getCookies().then(function (cookies) {
        console.log('cookie details => ', cookies);
    });
})();
  
import org.openqa.selenium.Cookie
import org.openqa.selenium.chrome.ChromeDriver

fun main() {
    val driver = ChromeDriver()
    try {
        driver.get("https://example.com")
        driver.manage().addCookie(Cookie("test1", "cookie1"))
        val cookie1 = Cookie("test2", "cookie2")
        driver.manage().addCookie(cookie1)

        // Borra la cookie con el nombre 'test1'
        driver.manage().deleteCookieNamed("test1")

        // Borra una cookie pasando un objeto cookie del contexto actual del navegador. 
        driver.manage().deleteCookie(cookie1)
    } finally {
        driver.quit()
    }
}R  
  

Borra todas las Cookies

Borra todas las cookies del contexto actual del navegador.

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

public class deleteAllCookies {
    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        try {
            driver.get("http://www.example.com");
            driver.manage().addCookie(new Cookie("test1", "cookie1"));
            driver.manage().addCookie(new Cookie("test2", "cookie2"));

            // Borra todas las cookies
            driver.manage().deleteAllCookies();
        } finally {
            driver.quit();
        }
    }
}
  
from selenium import webdriver
driver = webdriver.Chrome()

# Navega a la URL
driver.get("http://www.example.com")
driver.add_cookie({"name": "test1", "value": "cookie1"})
driver.add_cookie({"name": "test2", "value": "cookie2"})

#  Borra todas las cookies
driver.delete_all_cookies()
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace DeleteAllCookies {
 class DeleteAllCookies {
  public static void Main(string[] args) {
   IWebDriver driver = new ChromeDriver();
   try {
    // Navega a la URL
    driver.Navigate().GoToUrl("https://example.com");
    driver.Manage().Cookies.AddCookie(new Cookie("test1", "cookie1"));
    driver.Manage().Cookies.AddCookie(new Cookie("test2", "cookie2"));

    // Borra todas las cookies
    driver.Manage().Cookies.DeleteAllCookies();
   } finally {
    driver.Quit();
   }
  }
 }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  driver.get 'https://www.example.com'
  driver.manage.add_cookie(name: "test1", value: "cookie1")
  driver.manage.add_cookie(name: "test2", value: "cookie2")

  # Borra todas las cookies
  driver.manage.delete_all_cookies
ensure
  driver.quit
end
  
const {Builder} = require('selenium-webdriver');
(async function example() {
    let driver = new Builder()
        .forBrowser('chrome')
        .build();

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

    // Añade varias cookies
    await driver.manage().addCookie({name:'test1', value:'cookie1'});
    await driver.manage().addCookie({name:'test2', value:'cookie2'});

    // Borra todas las cookies
    await driver.manage().deleteAllCookies();
})();
  
import org.openqa.selenium.Cookie
import org.openqa.selenium.chrome.ChromeDriver

fun main() {
    val driver = ChromeDriver()
    try {
        driver.get("https://example.com")
        driver.manage().addCookie(Cookie("test1", "cookie1"))
        driver.manage().addCookie(Cookie("test2", "cookie2"))

        // Borra todas las cookies
        driver.manage().deleteAllCookies()
    } finally {
        driver.quit()
    }
}  
  

Este atributo permite al usuario enseñar a los navegadores a controlar que cookies son mandadas junto con las peticiones iniciadas por servicios externos. Esto introducido con la intención de prevenir ataques CSRF (Cross-Site Request Forgery) El atributo Same-Site acepta dos parámetros como instrucciones:

Estricto:

Cuando el atributo sameSite esta fijado como Strict (estricto en español), la cookie no será enviada junto a las peticiones iniciadas por paginas web externas.

Laxo:

Cuando el atributo sameSite se fija como Lax (Laxo en español), la cookie será enviada junto con la petición GET iniciada por paginas web externas.

Note: As of now this feature is landed in chrome(80+version), Firefox(79+version) and works with Selenium 4 and later versions.

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

public class cookieTest {
  public static void main(String[] args) {
    WebDriver driver = new ChromeDriver();
    try {
      driver.get("http://www.example.com");
      Cookie cookie = new Cookie.Builder("key", "value").sameSite("Strict").build();
      Cookie cookie1 = new Cookie.Builder("key", "value").sameSite("Lax").build();
      driver.manage().addCookie(cookie);
      driver.manage().addCookie(cookie1);
      System.out.println(cookie.getSameSite());
      System.out.println(cookie1.getSameSite());
    } finally {
      driver.quit();
    }
  }
}
  
from selenium import webdriver

driver = webdriver.Chrome()

driver.get("http://www.example.com")
# Añade la cookie en el contexto actual del navegador con el parámetro 
# sameSite como 'Strict' (o) 'Lax'
driver.add_cookie({"name": "foo", "value": "value", 'sameSite': 'Strict'})
driver.add_cookie({"name": "foo1", "value": "value", 'sameSite': 'Lax'})
cookie1 = driver.get_cookie('foo')
cookie2 = driver.get_cookie('foo1')
print(cookie1)
print(cookie2)
  
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace SameSiteCookie {
  class SameSiteCookie {
    static void Main(string[] args) {
      IWebDriver driver = new ChromeDriver();
      try {
        driver.Navigate().GoToUrl("http://www.example.com");

        var cookie1Dictionary = new System.Collections.Generic.Dictionary<string, object>() {
          { "name", "test1" }, { "value", "cookie1" }, { "sameSite", "Strict" } };
        var cookie1 = Cookie.FromDictionary(cookie1Dictionary);

        var cookie2Dictionary = new System.Collections.Generic.Dictionary<string, object>() {
          { "name", "test2" }, { "value", "cookie2" }, { "sameSite", "Lax" } };
        var cookie2 = Cookie.FromDictionary(cookie2Dictionary);

        driver.Manage().Cookies.AddCookie(cookie1);
        driver.Manage().Cookies.AddCookie(cookie2);

        System.Console.WriteLine(cookie1.SameSite);
        System.Console.WriteLine(cookie2.SameSite);
      } finally {
        driver.Quit();
      }
    }
  }
}
  
require 'selenium-webdriver'
driver = Selenium::WebDriver.for :chrome

begin
  driver.get 'https://www.example.com'
  # Adds the cookie into current browser context with sameSite 'Strict' (or) 'Lax'
  driver.manage.add_cookie(name: "foo", value: "bar", same_site: "Strict")
  driver.manage.add_cookie(name: "foo1", value: "bar", same_site: "Lax")
  puts driver.manage.cookie_named('foo')
  puts driver.manage.cookie_named('foo1')
ensure
  driver.quit
end
  
const {Builder} = require('selenium-webdriver');
(async function example() {
    let driver = new Builder()
        .forBrowser('chrome')
        .build();
        
    await driver.get('https://www.example.com');
    
    // Añade la cookie en el contexto actual del navegador con el parámetro 
    // sameSite como 'Strict' (o) 'Lax'
    await driver.manage().addCookie({name:'key', value: 'value', sameSite:'Strict'});
    await driver.manage().addCookie({name:'key', value: 'value', sameSite:'Lax'});
    console.log(await driver.manage().getCookie('key'));
})();
  
import org.openqa.selenium.Cookie
import org.openqa.selenium.chrome.ChromeDriver

fun main() {
    val driver = ChromeDriver()
    try {
        driver.get("http://www.example.com")
        val cookie = Cookie.Builder("key", "value").sameSite("Strict").build()
        val cookie1 = Cookie.Builder("key", "value").sameSite("Lax").build()
        driver.manage().addCookie(cookie)
        driver.manage().addCookie(cookie1)
        println(cookie.getSameSite())
        println(cookie1.getSameSite())
    } finally {
        driver.quit()
    }
} 
  

5 - Chrome DevTools Protocol

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

While Selenium 4 provides direct access to the Chrome DevTools Protocol (CDP), it is highly encouraged that you use the WebDriver Bidi APIs instead.

Many browsers provide “DevTools” – a set of tools that are integrated with the browser that developers can use to debug web apps and explore the performance of their pages. Google Chrome’s DevTools make use of a protocol called the Chrome DevTools Protocol (or “CDP” for short). As the name suggests, this is not designed for testing, nor to have a stable API, so functionality is highly dependent on the version of the browser.

WebDriver Bidi is the next generation of the W3C WebDriver protocol and aims to provide a stable API implemented by all browsers, but it’s not yet complete. Until it is, Selenium provides access to the CDP for those browsers that implement it (such as Google Chrome, or Microsoft Edge, and Firefox), allowing you to enhance your tests in interesting ways. Some examples of what you can do with it are given below.

Emulate Geo Location

Some applications have different features and functionalities across different locations. Automating such applications is difficult because it is hard to emulate the geo-locations in the browser using Selenium. But with the help of Devtools, we can easily emulate them. Below code snippet demonstrates that.

ChromeDriver driver = new ChromeDriver();
DevTools devTools = driver.getDevTools();
devTools.createSession();
devTools.send(Emulation.setGeolocationOverride(Optional.of(52.5043),
                                               Optional.of(13.4501),
                                               Optional.of(1)));
driver.get("https://my-location.org/");
driver.quit();
  
from selenium import webdriver
from selenium.webdriver.chrome.service import Service

def geoLocationTest():
    driver = webdriver.Chrome()
    Map_coordinates = dict({
        "latitude": 41.8781,
        "longitude": -87.6298,
        "accuracy": 100
        })
    driver.execute_cdp_cmd("Emulation.setGeolocationOverride", Map_coordinates)
    driver.get("<your site url>")
  
using System.Threading.Tasks;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.DevTools;
// Replace the version to match the Chrome version
using OpenQA.Selenium.DevTools.V87.Emulation;

namespace dotnet_test {
  class Program {
    public static void Main(string[] args) {
      GeoLocation().GetAwaiter().GetResult();
    }

    public static async Task GeoLocation() {
      ChromeDriver driver = new ChromeDriver();
      DevToolsSession devToolsSession = driver.CreateDevToolsSession();
      var geoLocationOverrideCommandSettings = new SetGeolocationOverrideCommandSettings();

      geoLocationOverrideCommandSettings.Latitude = 51.507351;
      geoLocationOverrideCommandSettings.Longitude = -0.127758;
      geoLocationOverrideCommandSettings.Accuracy = 1;

      await devToolsSession
        .GetVersionSpecificDomains<OpenQA.Selenium.DevTools.V87.DevToolsSessionDomains>()
        .Emulation
        .SetGeolocationOverride(geoLocationOverrideCommandSettings);

        driver.Url = "<your site url>";
        }
    }
}
  
require 'selenium-webdriver'

driver = Selenium::WebDriver.for :chrome

begin
  # Latitude and longitude of Tokyo, Japan
  coordinates = { latitude: 35.689487,
                  longitude: 139.691706,
                  accuracy: 100 }
  driver.execute_cdp('Emulation.setGeolocationOverride', coordinates)
  driver.get 'https://www.google.com/search?q=selenium'
ensure
  driver.quit
end
  
const { Builder } = require("selenium-webdriver");

(async function geoLocationTest() {
  const driver = await new Builder().forBrowser("chrome").build();
  try {
    await driver.get("https://my-location.org/");
    const pageCdpConnection = await driver.createCDPConnection('page');
    //Latitude and longitude of Tokyo, Japan
    const coordinates = {
      latitude: 35.689487,
      longitude: 139.691706,
      accuracy: 100,
    };
      await pageCdpConnection.execute(
        "Emulation.setGeolocationOverride",
        1,
        coordinates
      );
  } catch (e) {
    console.log(e)
  } finally {
     await driver.quit();
  }
})();
  
import org.openqa.selenium.chrome.ChromeDriver
import org.openqa.selenium.devtools.DevTools

fun main() {
    val driver =  ChromeDriver()
    val coordinates : HashMap<String, Any> = HashMap<String, Any> ()
    coordinates.put("latitude", 50.2334)
    coordinates.put("longitude", 0.2334)
    coordinates.put("accuracy", 1)
    driver.executeCdpCommand("Emulation.setGeolocationOverride", coordinates)
    driver.get("https://www.google.com")
}
  

Emulate Geo Location with the Remote WebDriver:

ChromeOptions chromeOptions = new ChromeOptions();
WebDriver driver = new RemoteWebDriver(new URL("<grid-url>"), chromeOptions);
driver = new Augmenter().augment(driver);

DevTools devTools = ((HasDevTools) driver).getDevTools();
devTools.createSession();

devTools.send(Emulation.setGeolocationOverride(Optional.of(52.5043),
                                               Optional.of(13.4501),
                                               Optional.of(1)));
 
driver.get("https://my-location.org/");
driver.quit();
  
from selenium import webdriver
#Replace the version to match the Chrome version
import selenium.webdriver.common.devtools.v93 as devtools

async def geoLocationTest():
    chrome_options = webdriver.ChromeOptions()
    driver = webdriver.Remote(
        command_executor='<grid-url>',
        options=chrome_options
    )

    async with driver.bidi_connection() as session:
        cdpSession = session.session
        await cdpSession.execute(devtools.emulation.set_geolocation_override(latitude=41.8781,longitude=-87.6298,accuracy=100))
    driver.get("https://my-location.org/")
    driver.quit()
  
using System.Threading.Tasks;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.DevTools;
// Replace the version to match the Chrome version
using OpenQA.Selenium.DevTools.V87.Emulation;

namespace dotnet_test {
  class Program {
    public static void Main(string[] args) {
      GeoLocation().GetAwaiter().GetResult();
    }

    public static async Task GeoLocation() {
      ChromeOptions chromeOptions = new ChromeOptions();
      RemoteWebDriver driver = new RemoteWebDriver(new Uri("<grid-url>"), chromeOptions);
      DevToolsSession devToolsSession = driver.CreateDevToolsSession();
      var geoLocationOverrideCommandSettings = new SetGeolocationOverrideCommandSettings();

      geoLocationOverrideCommandSettings.Latitude = 51.507351;
      geoLocationOverrideCommandSettings.Longitude = -0.127758;
      geoLocationOverrideCommandSettings.Accuracy = 1;

      await devToolsSession
        .GetVersionSpecificDomains<OpenQA.Selenium.DevTools.V87.DevToolsSessionDomains>()
        .Emulation
        .SetGeolocationOverride(geoLocationOverrideCommandSettings);

        driver.Url = "https://my-location.org/";
        }
    }
}
  
driver = Selenium::WebDriver.for(
:remote, 
:url => "<grid-url>",
:capabilities => :chrome)

begin
  # Latitude and longitude of Tokyo, Japan
  coordinates = { latitude: 35.689487,
                  longitude: 139.691706,
                  accuracy: 100 }
  devToolsSession = driver.devtools
  devToolsSession.send_cmd('Emulation.setGeolocationOverride', coordinates)
  driver.get 'https://my-location.org/'
  puts res
ensure
  driver.quit
end

  
const webdriver = require('selenium-webdriver');
const BROWSER_NAME = webdriver.Browser.CHROME;

async function getDriver() {
  return new webdriver.Builder()
  .usingServer('<grid-url>')
  .forBrowser(BROWSER_NAME)
  .build();
}

async function executeCDPCommands () {
 let driver = await getDriver();

 await driver.get("<your site url>");
 
 const cdpConnection = await driver.createCDPConnection('page');
  //Latitude and longitude of Tokyo, Japan
  const coordinates = {
    latitude: 35.689487,
    longitude: 139.691706,
    accuracy: 100,
  };
  await cdpConnection.execute(
    "Emulation.setGeolocationOverride",
    1,
    coordinates
  );
 await driver.quit();
}

executeCDPCommands(); 
  
import org.openqa.selenium.WebDriver
import org.openqa.selenium.chrome.ChromeOptions
import org.openqa.selenium.devtools.HasDevTools
// Replace the version to match the Chrome version
import org.openqa.selenium.devtools.v91.emulation.Emulation
import org.openqa.selenium.remote.Augmenter
import org.openqa.selenium.remote.RemoteWebDriver
import java.net.URL
import java.util.Optional

fun main() {
    val chromeOptions = ChromeOptions()
    var driver: WebDriver = RemoteWebDriver(URL("<grid-url>"), chromeOptions)
    driver = Augmenter().augment(driver)

    val devTools = (driver as HasDevTools).devTools
    devTools.createSession()

    devTools.send(
        Emulation.setGeolocationOverride(
            Optional.of(52.5043),
            Optional.of(13.4501),
            Optional.of(1)
        )
    )

    driver["https://my-location.org/"]
    driver.quit()
}

  

Override Device Mode

Using Selenium’s integration with CDP, one can override the current device mode and simulate a new mode. Width, height, mobile, and deviceScaleFactor are required parameters. Optional parameters include scale, screenWidth, screenHeight, positionX, positionY, dontSetVisible, screenOrientation, viewport, and displayFeature.

ChromeDriver driver = new ChromeDriver();
DevTools devTools = driver.getDevTools();
devTools.createSession();
// iPhone 11 Pro dimensions
devTools.send(Emulation.setDeviceMetricsOverride(375,
                                                 812,
                                                 50,
                                                 true,
                                                 Optional.empty(),
                                                 Optional.empty(),
                                                 Optional.empty(),
                                                 Optional.empty(),
                                                 Optional.empty(),
                                                 Optional.empty(),
                                                 Optional.empty(),
                                                 Optional.empty(),
                                                 Optional.empty()));
driver.get("https://selenium.dev/");
driver.quit();
# Please raise a PR to add code sample
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.DevTools;
using System.Threading.Tasks;
using OpenQA.Selenium.DevTools.V91.Emulation;
using WebDriverManager;
using WebDriverManager.DriverConfigs.Impl;
using DevToolsSessionDomains = OpenQA.Selenium.DevTools.V91.DevToolsSessionDomains;

namespace Selenium4Sample {
public class ExampleDevice {

    protected IDevToolsSession session;
    protected IWebDriver driver;
    protected DevToolsSessionDomains devToolsSession;

    public async Task DeviceModeTest() {
      new DriverManager().SetUpDriver(new ChromeConfig());
      ChromeOptions chromeOptions = new ChromeOptions();
      //Set ChromeDriver
      driver = new ChromeDriver();
      //Get DevTools
      IDevTools devTools = driver as IDevTools;
      //DevTools Session
      session = devTools.GetDevToolsSession();

      var deviceModeSetting = new SetDeviceMetricsOverrideCommandSettings();
      deviceModeSetting.Width = 600;
      deviceModeSetting.Height = 1000;
      deviceModeSetting.Mobile = true;
      deviceModeSetting.DeviceScaleFactor = 50;

      await session
            .GetVersionSpecificDomains < OpenQA.Selenium.DevTools.V91.DevToolsSessionDomains > ()
            .Emulation
            .SetDeviceMetricsOverride(deviceModeSetting);

      driver.Url = "<your site url>";
    }
}
}
require 'selenium-webdriver'

driver = Selenium::WebDriver.for :chrome

begin
  metrics = { width: 300,
              height: 200,
              mobile: true,
              deviceScaleFactor: 50 }
  driver.execute_cdp('Emulation.setDeviceMetricsOverride', metrics)
  driver.get 'https://www.google.com'
ensure
  driver.quit
end
const {Builder} = require('selenium-webdriver');
const firefox = require('selenium-webdriver/firefox');
const options = new firefox.Options();
// enable debugger for CDP
options.enableDebugger();

(async function example() {
  try {
    let driver = await new Builder().forBrowser('firefox').setFirefoxOptions(options).build();
    const pageCdpConnection = await driver.createCDPConnection('page');
    const metrics = {
      width: 300,
      height: 200,
      deviceScaleFactor: 50,
      mobile: true,
    };
    await pageCdpConnection.execute(
      "Emulation.setDeviceMetricsOverride",
      1,
      metrics
    );
    await driver.get("https://www.google.com");
    await driver.quit();
  } catch (e) {
    console.log(e);
  }
})();
fun kotlinOverridDeviceMode() {
  val driver = ChromeDriver()

  val deviceMetrics: Map<String, Any> = object : HashMap<String, Any>() {
    init {
        put("width", 600)
        put("height", 1000)
        put("mobile", true)
        put("deviceScaleFactor", 50)
    }
  }

  driver.executeCdpCommand("Emulation.setDeviceMetricsOverride", deviceMetrics)
  driver.get("https://www.google.com")
  driver.quit()
}

6 - ThreadGuard

Esta clase solo esta disponible en la librería de enlace de Java

ThreadGuard comprueba que se llama a un controlador solo desde el mismo hilo que lo creó. Los problemas de subprocesos, especialmente cuando se ejecutan pruebas en paralelo, pueden tener errores misteriosos y difícil de diagnosticar. El uso de este contenedor evita esta categoría de errores y generará una excepción cuando ocurran.

El siguiente ejemplo simula un choque de hilos:

public class DriverClash {
  //El hilo (thread) main (id 1) creó este controlador
  private WebDriver protectedDriver = ThreadGuard.protect(new ChromeDriver());

  static {
    System.setProperty("webdriver.chrome.driver", "<Set path to your Chromedriver>");
  }

  //Thread-1 (id 24) llama al mismo controlador causando el choque
  Runnable r1 = () -> {protectedDriver.get("https://selenium.dev");};
  Thread thr1 = new Thread(r1);

  void runThreads(){
    thr1.start();
  }

  public static void main(String[] args) {
    new DriverClash().runThreads();
  }
}

El resultado se muestra a continuación:

Exception in thread "Thread-1" org.openqa.selenium.WebDriverException:
Thread safety error; this instance of WebDriver was constructed
on thread main (id 1)and is being accessed by thread Thread-1 (id 24)
This is not permitted and *will* cause undefined behaviour

Como puede verse en el ejemplo:

  • protectedDriver Será creado en el hilo Main.
  • Utilizamos Java Runnable para iniciar un nuevo proceso y un nuevo Thread para ejecutar el proceso.
  • Ambos Thread chocarán porque el Thread principal no tiene protectedDriver en su memoria.
  • ThreadGuard.protect lanzará una excepción.

Nota:

Esto no reemplaza la necesidad de usar ThreadLocal para administrar los controladores cuando se ejecutan en paralelo.