Selenium WebDriver: verifica se l’elemento è presente

c’è un modo per verificare se un elemento è presente? Qualsiasi metodo findElement finirebbe in un’eccezione, ma non è quello che voglio, perché può essere che un elemento non sia presente e che sia corretto, che non sia un fallimento del test, quindi un’eccezione non può essere la soluzione.

Ho trovato questo post: Selenio c # Webdriver: Wait Until Element is Present, ma questo è per C # e io non sono molto bravo a farlo. Qualcuno può tradurre il codice in Java? Mi dispiace ragazzi, l’ho provato in Eclipse ma non riesco a inserirlo nel codice Java.

Questo è il codice:

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

    Usa findElements invece di findElement .

    findElements restituirà una lista vuota se non vengono trovati elementi corrispondenti invece di un’eccezione.

    Per verificare che un elemento sia presente, puoi provare questo

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

    Questo restituirà true se almeno un elemento è trovato e falso se non esiste.

    Che dire di un metodo privato che cerca semplicemente l’elemento e determina se è presente in questo modo:

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

    Questo sarebbe abbastanza facile e fa il lavoro.

    Modifica: potresti anche andare oltre e prendere un By elementLocator come parametro, eliminando i problemi se vuoi trovare l’elemento con qualcosa di diverso da id.

    Ho scoperto che questo funziona per Java:

     WebDriverWait waiter = new WebDriverWait(driver, 5000); waiter.until( ExpectedConditions.presenceOfElementLocated(by) ); driver.FindElement(by); 
     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  seconds return driver.findElement(by); } 

    Ho avuto lo stesso problema. Per me, a seconda del livello di authorization di un utente, alcuni collegamenti, pulsanti e altri elementi non verranno visualizzati nella pagina. Una parte della mia suite stava testando che mancano gli elementi che DOVREBBE mancare. Ho passato ore a cercare di capirlo. Finalmente ho trovato la soluzione perfetta.

    Ciò che fa è dire al browser di cercare tutti gli elementi basati su specificato. Se risulta in 0 , significa che non è stato trovato alcun elemento basato sulla specifica. Quindi ho il codice di eseguire una dichiarazione if per farmi sapere che non è stato trovato.

    Questo è in C# , quindi le traduzioni dovrebbero essere fatte su Java . Ma non dovrebbe essere troppo difficile.

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

    C’è anche un altro percorso che puoi seguire in base a ciò che ti serve per il tuo test.

    Lo snippet seguente sta verificando se esiste un elemento molto specifico sulla pagina. A seconda dell’esistenza dell’elemento, il test esegue un altro.

    Se l’elemento esiste e viene visualizzato sulla pagina, ho console.write fammi sapere e andare avanti. Se l’elemento in questione esiste, non riesco ad eseguire il test di cui avevo bisogno, che è il ragionamento principale alla base della necessità di impostarlo.

    Se l’elemento non esiste e non viene visualizzato sulla pagina. Ho il else nel if else esegue il test.

     IList 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. } 

    So di essere un po ‘in ritardo sulla risposta all’OP. Speriamo che questo aiuti qualcuno!

    Prova questo: chiama questo metodo e passa 3 argomenti:

    1. Variabile WebDriver. // assumendo driver_variable come driver.
    2. L’elemento che stai per controllare. Dovrebbe fornire dal metodo By. // ex: By.id (“id”)
    3. Limite di tempo in secondi.

    Esempio: 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; } 

    Puoi far funzionare il codice più velocemente abbreviando il timeout del selenium prima dell’istruzione catch.

    Io uso il seguente codice per verificare se un elemento è 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; } 

    Scrivi la seguente funzione / methos usando Java:

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

    Chiama il metodo con i parametri appropriati durante l’asserzione.

    se si utilizza rspec-Webdriver in ruby, è ansible utilizzare questo script presupponendo che un elemento non sia realmente presente ed è un test superato.

    Per prima cosa, scrivi questo metodo prima dal tuo file RB di class

     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 

    Quindi, sul tuo file spec, chiama quel metodo.

      before(:all) do @Test= Test.new(@browser) end @Test.element_present?.should == nil 

    Se l’elemento NON è presente, la tua specifica passerà, ma se l’elemento è presente, genererà un errore, test fallito.

    Questo funziona per me:

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

    Per trovare un particolare elemento è presente o no, dobbiamo usare il metodo findElements () invece di 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"); 

    questo è funzionato per me .. suggeriscimi se ho torto ..

    Questo dovrebbe farlo:

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

    Puoi provare l’attesa implicita: `

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

    `

    Oppure puoi provare l’attesa esplicita: `

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

    `

    Explicit controllerà se l’elemento è presente prima di un’azione. L’attesa implicita potrebbe essere chiamata in ogni punto del codice. Ad esempio dopo alcune azioni AJAX.

    Più potete trovare alla pagina SeleniumHQ: http://docs.seleniumhq.org/docs/04_webdriver_advanced.jsp

    Dando il mio frammento di codice. Quindi, il metodo seguente controlla se un pulsante web casuale ” Crea nuova applicazione ” esiste su una pagina o meno. Si noti che ho usato il periodo di attesa come 0 secondi.

     public boolean isCreateNewApplicationButtonVisible(){ WebDriverWait zeroWait = new WebDriverWait(driver, 0); ExpectedCondition 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; } } 

    Vorrei usare qualcosa di simile (con Scala [il codice nel vecchio “buono” Java 8 potrebbe essere simile a questo]):

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

    allora,

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

    Il modo più semplice che ho trovato in Java è:

     List linkSearch= driver.findElements(By.id("linkTag")); int checkLink=linkSearch.size(); if(checkLink!=0){ //do something you want} 
     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; } 
     public boolean isElementDisplayed() { return !driver.findElements(By.xpath("...")).isEmpty(); } 

    Di seguito sono riportati i modi per verificare se un elemento Web è presente o meno :

    Ho usato XPath come identificatore / localizzatore di elementi , ma puoi anche usare altri localizzatori.

    Soluzione I:

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

    Soluzione II:

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

    Soluzione III:

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

    Personalmente, cerco sempre una combinazione delle risposte di cui sopra e creo un metodo di utilità statica riutilizzabile che utilizza il suggerimento size () <0:

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

    Questo è pulito, riutilizzabile, mantenibile ... tutte cose buone 😉