selenium-webdriver
Espere

Tipos de Espera en Selenium WebDriver

Al ejecutar cualquier aplicación web, es necesario tener en cuenta el tiempo de carga. Si su código intenta acceder a cualquier elemento que aún no esté cargado, WebDriver lanzará una excepción y su secuencia de comandos se detendrá.

Hay tres tipos de esperas:

• Esperas implícitas
• Esperas explícitas
• Espera fluida

Las esperas implícitas se usan para establecer el tiempo de espera en todo el programa, mientras que las esperas explícitas se usan solo en partes específicas.

Espera implícita

Una espera implícita es decirle a WebDriver que sondee el DOM durante un cierto período de tiempo cuando intenta encontrar un elemento o elementos si no están disponibles de inmediato. Las esperas implícitas son básicamente su forma de decirle a WebDriver la latencia que desea ver si el elemento web especificado no está presente que WebDriver está buscando. La configuración predeterminada es 0. Una vez establecida, la espera implícita se establece para la vida de la instancia del objeto WebDriver. La espera implícita se declara en la parte de creación de instancias del código mediante el siguiente fragmento de código.

Ejemplo en Java :

driver.manage().timeouts().implicitlyWait(15, TimeUnit.SECONDS);
// You need to import the following class - import java.util.concurrent.TimeUnit;

Ejemplo en C # :

driver.Manage().Timeouts().ImplicitlyWait(TimeSpan.FromSeconds(15));

Entonces, en este caso, le está diciendo a WebDriver que debe esperar 15 segundos en los casos en que el elemento especificado no esté disponible en la interfaz de usuario (DOM).

Espera explícita

Puede encontrar instancias en las que algún elemento demore más en cargarse. Establecer la espera implícita para tales casos no tiene sentido ya que el navegador esperará innecesariamente el mismo tiempo para cada elemento, lo que aumenta el tiempo de automatización. La espera explícita ayuda aquí al pasar por alto la espera implícita para algunos elementos específicos.

Las esperas explícitas son esperas inteligentes que se limitan a un elemento web en particular. Usando esperas explícitas, básicamente le está diciendo a WebDriver al máximo que debe esperar X unidades de tiempo antes de que se rinda.

Las esperas explícitas se realizan utilizando las clases WebDriverWait y ExpectedConditions. En el siguiente ejemplo, esperaremos hasta 10 segundos para que un elemento cuyo id es un nombre de usuario se haga visible antes de continuar con el siguiente comando. Aquí están los pasos.

Ejemplo en Java :

//Import these two packages:
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

//Declare a WebDriverWait variable. In this example, we will use myWaitVar as the name of the variable.
WebDriverWait myWaitVar = new WebDriverWait(driver, 30);

//Use myWaitVar with ExpectedConditions on portions where you need the explicit wait to occur. In this case, we will use explicit wait on the username input before we type the text tutorial onto it.
myWaitVar.until(ExpectedConditions.visibilityOfElementLocated(By.id(“username”)));
driver.findElement(By.id(“username”)).sendKeys(“tutorial”);

La clase ExpectedConditions tiene algunas condiciones comunes predefinidas para esperar un elemento. Haga clic aquí para ver la lista de estas condiciones en el enlace de Java.

Ejemplo en C # :

using OpenQA.Selenium;
using OpenQA.Selenium.Support.UI;
using OpenQA.Selenium.PhantomJS;

// You can use any other WebDriver you want, such as ChromeDriver.
using (var driver = new PhantomJSDriver())
{
    driver.Navigate().GoToUrl("http://somedomain/url_that_delays_loading");

    // We aren't going to use it more than once, so no need to declare this a variable.
    new WebDriverWait(driver, TimeSpan.FromSeconds(10))
        .Until(ExpectedConditions.ElementIsVisible(By.Id("element-id")));

    // After the element is detected by the previous Wait, 
    // it will display the element's text
    Console.WriteLine(driver.FindElement(By.Id("element-id")).Text);
}

En este ejemplo, el sistema esperará 10 segundos hasta que el elemento esté visible. Si el elemento no será visible después del tiempo de espera, el WebDriver lanzará una WebDriverTimeoutException .

Tenga en cuenta que: si el elemento es visible antes del tiempo de espera de 10 segundos, el sistema procederá inmediatamente a continuar con el proceso.

Espera fluida

A diferencia de la espera implícita y explícita, la espera fluida utiliza dos parámetros. Tiempo de espera y frecuencia de sondeo. Digamos que tenemos un valor de tiempo de espera de 30 segundos y la frecuencia de sondeo de 2 segundos. WebDriver comprobará el elemento después de cada 2 segundos hasta el valor de tiempo de espera (30 segundos). Después de que se excede el valor de tiempo de espera sin ningún resultado, se lanza una excepción. A continuación se muestra un código de ejemplo que muestra la implementación de espera fluida.

Ejemplo en Java :

Wait wait = new FluentWait(driver).withTimeout(30, SECONDS).pollingEvery(2, SECONDS).ignoring(NoSuchElementException.class);


WebElement testElement = wait.until(new Function() {
    public WebElement apply(WebDriver driver) {
        return driver.findElement(By.id("testId"));
    }
});

Otra ventaja de usar la espera fluida es que podemos ignorar tipos específicos de excepciones (por ejemplo, NoSuchElementExceptions) mientras esperamos. Debido a todas estas disposiciones, la espera fluida es útil en las aplicaciones AJAX, así como en escenarios cuando el tiempo de carga del elemento fluctúa con frecuencia. El uso estratégico de la espera fluida mejora significativamente los esfuerzos de automatización.

Diferentes tipos de condiciones de espera explícitas.

En espera explícita, esperas que ocurra una condición. Por ejemplo, desea esperar hasta que se pueda hacer clic en un elemento.

Aquí hay una demostración de algunos problemas comunes.

Tenga en cuenta: En todos estos ejemplos, puede usar cualquier By como un localizador, como nombre de classname , xpath , link text , tag name o cssSelector

Espera hasta que el elemento sea visible

Por ejemplo, si su sitio web tarda en cargarse, puede esperar hasta que la página finalice la carga y su elemento sea visible para el WebDriver.

DO#

WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
wait.Until(ExpectedConditions.ElementIsVisible(By.Id("element-id")));

Java

WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("element-id")));

Espera hasta que el elemento ya no sea visible.

Igual que antes, pero invertido.

DO#

WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
wait.Until(ExpectedConditions.InvisibilityOfElementLocated(By.Id("element-id")));

Java

WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.id("element-id")));

Espera hasta que el texto esté presente en el elemento especificado.

DO#

IWebElement element = driver.FindElement(By.Id("element-id"));

WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
wait.Until(ExpectedConditions.TextToBePresentInElement(element, "text"));

Java

WebElement element = driver.findElement(By.id("element-id"));

WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.textToBePresentInElement(element, "text"));

Si vas al enlace dado arriba, verás todas las condiciones de espera allí.

La diferencia entre el uso de estas condiciones de espera se encuentra en su parámetro de entrada.

Eso significa que necesita pasar el elemento Web si su parámetro de entrada es WebElement, debe pasar el localizador de elementos si toma el localizador Por como su parámetro de entrada.

Elija sabiamente qué tipo de condición de espera desea utilizar.

Esperando solicitudes de Ajax para completar

DO#

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

namespace WebDriver Tests
{
    class WebDriverWaits
    {
        static void Main()
        {
            IWebDriver driver = new ChromeDriver(@"C:\WebDriver");
            
            driver.Navigate().GoToUrl("page with ajax requests");
            CheckPageIsLoaded(driver);

            // Now the page is fully loaded, you can continue with further tests.
        }

        private void CheckPageIsLoaded(IWebDriver driver)
        {
            while (true)
            {
                bool ajaxIsComplete = (bool)(driver as IJavaScriptExecutor).ExecuteScript("return jQuery.active == 0");
                if (ajaxIsComplete)
                    return;
                Thread.Sleep(100);
            }
        }
    }
}

Este ejemplo es útil para páginas donde se realizan solicitudes ajax, aquí usamos el IJavaScriptExecutor para ejecutar nuestro propio código JavaScript. Ya que está dentro de un while de bucle seguirá funcionando hasta que ajaxIsComplete == true y así se ejecuta la instrucción de retorno.

Verificamos que todas las solicitudes de ajax estén completas al confirmar que jQuery.active es igual a 0 . Esto funciona porque cada vez que se realiza una nueva solicitud de ajax jQuery.active se incrementa y cada vez que una solicitud complementa se decrementa, de esto podemos deducir que cuando jQuery.active == 0 todas las solicitudes de ajax deben completarse.

Espera fluida

La espera fluida es una superclase de espera explícita ( WebDriverWait ) que es más configurable ya que puede aceptar un argumento para la función de espera. Transmitiré la espera implícita , ya que es una buena práctica evitarla.

Uso (Java):

Wait wait = new FluentWait<>(this.driver)
        .withTimeout(driverTimeoutSeconds, TimeUnit.SECONDS)
        .pollingEvery(500, TimeUnit.MILLISECONDS)
        .ignoring(StaleElementReferenceException.class)
        .ignoring(NoSuchElementException.class)
        .ignoring(ElementNotVisibleException.class);

WebElement foo = wait.until(ExpectedConditions.presenceOfElementLocated(By.yourBy));

// or use your own predicate:
WebElement foo = wait.until(new Function() {
  public WebElement apply(WebDriver driver) {
    return element.getText().length() > 0;
  }
});

Cuando usa la espera explícita con sus valores predeterminados, es simplemente un FluentWait<WebDriver> con valores predeterminados de: DEFAULT_SLEEP_TIMEOUT = 500; y haciendo NotFoundException omiso de NotFoundException .

Espera fluida

Cada instancia de FluentWait define la cantidad máxima de tiempo para esperar una condición, así como la frecuencia con la que se verifica la condición. Además, el usuario puede configurar la espera para ignorar tipos específicos de excepciones mientras espera, como NoSuchElementExceptions al buscar un elemento en la página. Está asociado con el controlador.

Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)
.withTimeout(30, SECONDS) //actuall wait for the element to pe present
.pollingEvery(5, SECONDS) //selenium will keep looking for the element after every 5seconds
.ignoring(NoSuchElementException.class); //while ignoring this condition
wait.until(ExpectedConditions.visibilityOf(driver.findElement(By.id("username"));