java - esperar - selenium webdriver metodos

Selenium WebDriver-Prueba si el elemento está presente

Question

¿Hay alguna manera de probar si un elemento está presente? Cualquier método findElement terminaría en una excepción, pero eso no es lo que quiero, porque puede ser que un elemento no esté presente y que esté bien, eso no es un fracaso de la prueba, por lo que una excepción no puede ser la solución.

He encontrado esta publicación: Selenium c # Webdriver: Espere hasta que el elemento esté presente Pero esto es para C # y no soy muy bueno en eso. ¿Alguien puede traducir el código a Java? Lo siento muchachos, lo probé en Eclipse pero no entiendo bien el código de Java.

Este es el código:

public static class WebDriverExtensions{
    public static IWebElement FindElement(this IWebDriver driver, By by, int timeoutInSeconds){

        if (timeoutInSeconds > 0){
            var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
            return wait.Until(drv => drv.FindElement(by));
        }

        return driver.FindElement(by);
    }
}

Answer 1

¿Qué pasa con un método privado que simplemente busca el elemento y determina si está presente así:

private boolean existsElement(String id) {
    try {
        driver.findElement(By.id(id));
    } catch (NoSuchElementException e) {
        return false;
    }
    return true;
}

Esto sería bastante fácil y hace el trabajo.

Editar: incluso podría ir más allá y tomar un parámetro By elementLocator , eliminando los problemas si quiere encontrar el elemento por otra By elementLocator que no sea id.

Answer 2

Dando mi fragmento de código. Por lo tanto, el siguiente método verifica si existe un botón de elemento web aleatorio '' Crear nueva aplicación '' en una página o no. Tenga en cuenta que he usado el período de espera como 0 segundos.

public boolean isCreateNewApplicationButtonVisible(){
    WebDriverWait zeroWait = new WebDriverWait(driver, 0);
    ExpectedCondition<WebElement> c = ExpectedConditions.presenceOfElementLocated(By.xpath("//input[@value=''Create New Application'']"));
    try {
        zeroWait.until(c);
        logger.debug("Create New Application button is visible");
        return true;
    } catch (TimeoutException e) {
        logger.debug("Create New Application button is not visible");
        return false;
    }
}

Answer 3

Descubrí que esto funciona para Java:

WebDriverWait waiter = new WebDriverWait(driver, 5000);
waiter.until( ExpectedConditions.presenceOfElementLocated(by) );
driver.FindElement(by);

Answer 4

Escriba la siguiente función / methos usando Java:

protected boolean isElementPresent(By by){
        try{
            driver.findElement(by);
            return true;
        }
        catch(NoSuchElementException e){
            return false;
        }
    }

Llame al método con el parámetro apropiado durante la aserción.

Answer 5

Esto debería hacerlo:

try {
    driver.findElement(By.id(id));
} catch (NoSuchElementException e) {
    //do what you need here if you were expecting
    //the element wouldn''t exist
}

Answer 6

Esto funciona para mí:

 if(!driver.findElements(By.xpath("//*[@id=''submit'']")).isEmpty()){
    //THEN CLICK ON THE SUBMIT BUTTON
}else{
    //DO SOMETHING ELSE AS SUBMIT BUTTON IS NOT THERE
}

Answer 7

Intenta esto: llama a este método y pasa 3 argumentos:

1. Variable de WebDriver. // asumiendo driver_variable como driver.
2. El elemento que vas a verificar Debería proporcionar desde el método By. // ex: By.id ("id")
3. Límite de tiempo en segundos

Ejemplo: waitForElementPresent (driver, By.id ("id"), 10);

public static WebElement waitForElementPresent(WebDriver driver, final By by, int timeOutInSeconds) {

        WebElement element; 

        try{
            driver.manage().timeouts().implicitlyWait(0, TimeUnit.SECONDS); //nullify implicitlyWait() 

            WebDriverWait wait = new WebDriverWait(driver, timeOutInSeconds); 
            element = wait.until(ExpectedConditions.presenceOfElementLocated(by));

            driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS); //reset implicitlyWait
            return element; //return the element
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return null; 
    }

Answer 8

La forma más simple que encontré en Java es:

List<WebElement> linkSearch=  driver.findElements(By.id("linkTag"));
int checkLink=linkSearch.size();
if(checkLink!=0){  //do something you want}

Answer 9

Las siguientes son formas de verificar si un elemento web está presente o no :

He usado XPath como identificador / localizador de elementos , pero también puede usar otros localizadores.

Solución I:

public boolean isElementPresent(String xpathOfElement){
    try{
        driver.findElement(By.xpath(xpathOfElement));
        return true;
    }
    catch(NoSuchElementException e){
        return false;
    }
}

Solución II:

public boolean isElementPresent(String xpathOfElement){
    boolean isPresent = false;
    if(!driver.findElements(By.xpath(xpathOfElement)).isEmpty()){
        isPresent=true;
    }
    return isPresent;
}

Solución III:

public boolean isElementPresent(String xpathOfElement){
    return driver.findElements(By.xpath(xpathOfElement)).size() > 0;
}

Answer 10

Para encontrar un elemento en particular está presente o no, tenemos que usar el método findElements () en lugar de findElement () ..

int i=driver.findElements(By.xpath(".......")).size();
if(i=0)
System.out.println("Element is not present");
else
System.out.println("Element is present");

esto se trabajó para mí ... sugiérame si estoy equivocado ...

Answer 11

Personalmente, siempre busco una combinación de las respuestas anteriores y creo un método de utilidad estática reutilizable que utiliza la sugerencia size () <0:

public Class Utility {
   ...
   public static boolean isElementExist(WebDriver driver, By by) {
      return driver.findElements(by).size() < 0;
   ...
}

Esto es limpio, reutilizable, fácil de mantener ... todas esas cosas buenas ;-)

Answer 12

Puede hacer que el código se ejecute más rápido al acortar el tiempo de espera de selenio antes de su declaración de captura de prueba.

Utilizo el siguiente código para verificar si un elemento está presente.

protected boolean isElementPresent(By selector) {
    selenium.manage().timeouts().implicitlyWait(1, TimeUnit.SECONDS);
    logger.debug("Is element present"+selector);
    boolean returnVal = true;
    try{
        selenium.findElement(selector);
    } catch (NoSuchElementException e){
        returnVal = false;
    } finally {
        selenium.manage().timeouts().implicitlyWait(15, TimeUnit.SECONDS);
    }
    return returnVal;
}

Answer 13

Puedes probar la espera implícita: `

WebDriver driver = new FirefoxDriver();
driver.Manage().Timeouts().ImplicitlyWait(TimeSpan.FromSeconds(10));
driver.Url = "http://somedomain/url_that_delays_loading";
IWebElement myDynamicElement = driver.FindElement(By.Id("someDynamicElement"));

`

O bien, puede intentar esperar explícitamente uno: `

IWebDriver driver = new FirefoxDriver();
driver.Url = "http://somedomain/url_that_delays_loading";
WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
IWebElement myDynamicElement = wait.Until<IWebElement>((d) =>
    {
        return d.FindElement(By.Id("someDynamicElement"));
    });

`

Explícito verificará si el elemento está presente antes de alguna acción. La espera implícita podría ser llamada en cualquier lugar del código. Por ejemplo, después de algunas acciones AJAX.

Puedes encontrar más en la página de SeleniumHQ: http://docs.seleniumhq.org/docs/04_webdriver_advanced.jsp

Answer 14

Tuve el mismo problema. Para mí, dependiendo del nivel de permiso de un usuario, algunos enlaces, botones y otros elementos no se mostrarán en la página. Parte de mi suite estaba probando que faltan los elementos que DEBEN faltar. Pasé horas tratando de resolver esto. Finalmente encontré la solución perfecta.

Lo que hace esto es decirle al navegador que busque cualquiera y todos los elementos basados ​​en especificados. Si resulta en 0 , eso significa que no se encontraron elementos basados ​​en la especificación. Luego tengo el código ejecutar una declaración if para decirme que no fue encontrado.

Esto está en C# , por lo que las traducciones deberían realizarse en Java . Pero no debería ser demasiado difícil.

public void verifyPermission(string link)
{
    IList<IWebElement> adminPermissions = driver.FindElements(By.CssSelector(link));
    if (adminPermissions.Count == 0)
    {
        Console.WriteLine("User''s permission properly hidden");
    }
}

También hay otro camino que puede seguir dependiendo de lo que necesite para su prueba.

El siguiente fragmento está revisando para ver si existe un elemento muy específico en la página. Dependiendo de la existencia del elemento, tengo la prueba ejecute un if else.

Si el elemento existe y se muestra en la página, tengo console.write házmelo saber y seguir adelante. Si el elemento en cuestión existe, no puedo ejecutar la prueba que necesitaba, que es el principal razonamiento detrás de la necesidad de configurar esto.

Si el elemento No existe, y no se muestra en la página. Tengo el else en el if else ejecute la prueba.

IList<IWebElement> deviceNotFound = driver.FindElements(By.CssSelector("CSS LINK GOES HERE"));
//if the element specified above results in more than 0 elements and is displayed on page execute the following, otherwise execute whats in the else statement
if (deviceNotFound.Count > 0 && deviceNotFound[0].Displayed){
    //script to execute if element is found
} else {
    //Test script goes here.
}

Sé que llegué un poco tarde a la respuesta al OP. ¡Espero que esto ayude a alguien!

Answer 15

Use findElements lugar de findElement .

findElements devolverá una lista vacía si no se encuentran elementos coincidentes en lugar de una excepción.

Para verificar que un elemento esté presente, puedes intentar esto

Boolean isPresent = driver.findElements(By.yourLocator).size() > 0

Esto devolverá verdadero si se encuentra al menos un elemento y falso si no existe.

Answer 16

Yo usaría algo así como (con Scala [el código en el antiguo "buen" Java 8 puede ser similar a esto]):

object SeleniumFacade {

  def getElement(bySelector: By, maybeParent: Option[WebElement] = None, withIndex: Int = 0)(implicit driver: RemoteWebDriver): Option[WebElement] = {
    val elements = maybeParent match {
      case Some(parent) => parent.findElements(bySelector).asScala
      case None => driver.findElements(bySelector).asScala
    }
    if (elements.nonEmpty) {
      Try { Some(elements(withIndex)) } getOrElse None
    } else None
  }
  ...
}

por lo que entonces,

val maybeHeaderLink = SeleniumFacade getElement(By.xpath(".//a"), Some(someParentElement))

Answer 17

si está utilizando rspec-Webdriver en ruby, puede usar este script suponiendo que un elemento realmente no debería estar presente y es una prueba aprobada.

Primero, escribe este método primero desde tu clase RB file

class Test
 def element_present?
    begin
        browser.find_element(:name, "this_element_id".displayed?
        rescue Selenium::WebDriver::Error::NoSuchElementError
            puts "this element should not be present"
        end
 end

Luego, en su archivo de especificaciones, llame a ese método.

  before(:all) do    
    @Test= Test.new(@browser)
  end

 @Test.element_present?.should == nil

Si su elemento NO está presente, su especificación pasará, pero si el elemento está presente, lanzará un error, la prueba falló.

Answer 18

public boolean isElementDisplayed() {
        return !driver.findElements(By.xpath("...")).isEmpty();
    }

Answer 19

public boolean isElementFound( String text) {
        try{

            WebElement webElement = appiumDriver.findElement(By.xpath(text));
            System.out.println("isElementFound : true :"+text + "true");

        }catch(NoSuchElementException e){
            System.out.println("isElementFound : false :"+text);
            return false;
        }
        return true;
    }

Answer 20

public static WebElement FindElement(WebDriver driver, By by, int timeoutInSeconds)
{
    WebDriverWait wait = new WebDriverWait(driver, timeoutInSeconds);
    wait.until( ExpectedConditions.presenceOfElementLocated(by) ); //throws a timeout exception if element not present after waiting <timeoutInSeconds> seconds
    return driver.findElement(by);
}