WebDriver au sélénium-Test si l'élément est présent

à propos d'une méthode privée qui a tout simplement l'air de l'élément et détermine si elle est présente comme ceci:

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

ce serait assez facile et fait le travail.

Edit: vous pouvez même aller plus loin et prendre un By elementLocator comme paramètre, éliminant les problèmes si vous voulez trouver l'élément par quelque chose d'autre que id.

j'ai trouvé que cela fonctionne pour 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 <timeoutInSeconds> seconds
    return driver.findElement(by);
}

j'ai eu le même problème. Pour moi, selon le niveau de permission d'un utilisateur, certains liens, boutons et autres éléments ne seront pas affichés sur la page. Une partie de ma suite vérifiait que les éléments qui devraient être manquants, sont manquants. J'ai passé des heures à essayer de comprendre cela. J'ai enfin trouvé la solution idéale.

ce que cela fait, c'est dire au navigateur de rechercher tous les éléments basés spécifiés. Si cela aboutit à 0 , cela signifie qu'aucun élément basé sur la spécification a été trouvé. Ensuite, le code exécute une instruction if pour me faire savoir qu'il n'a pas été trouvé.

C'est dans C# , donc les traductions devront être faites à Java . Mais ne devrait pas être trop dur.

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

il y a aussi un autre chemin que vous pouvez prendre en fonction de ce dont vous avez besoin pour votre test.

l'extrait suivant est une vérification pour voir si un élément très spécifique existe sur la page. En fonction de la l'existence de l'élément j'ai le test exécuter un SI AUTREMENT.

si l'élément existe et s'affiche sur la page, j'ai console.write faites-moi savoir et passez à autre chose. Si l'élément en question Existe, Je ne peux pas exécuter le test dont j'avais besoin, ce qui est le principal raisonnement derrière la nécessité de mettre en place cela.

Si l'élément N'existe Pas, et n'est pas affiché sur la page. J'ai l'autre dans le SI AUTREMENT exécuter le test.

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

I je sais que je suis un peu en retard sur la réponse à L'opération. Espérons que cela aide quelqu'un!

essayez ceci: Appelez cette méthode et passez 3 arguments:

1. variable WebDriver. / en supposant que driver_variable soit le conducteur.
2. l'élément que vous allez vérifier. Devrait fournir par la méthode. // ex: By.id ("id")
3. temps limite en secondes.

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

vous pouvez faire courir le code plus vite en court-circuitant le temps d'arrêt de sélénium avant votre déclaration try catch.

j'utilise le code suivant pour vérifier si un élément est présent.

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

écrire la fonction / méthode suivante en utilisant Java:

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

appeler la méthode avec le paramètre approprié pendant l'affirmation.

si vous utilisez rspec-Webdriver dans ruby, vous pouvez utiliser ce script en supposant qu'un élément ne devrait pas vraiment être présent et que c'est un test réussi.

d'abord, écrivez cette méthode d'abord à partir de votre fichier de classe RB

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

ensuite, sur votre fichier spec, appelez cette méthode.

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

 @Test.element_present?.should == nil

Si l'élément n'est PAS présent, votre spec va passer, mais si l'élément est présent , il lèvera une erreur, le test a échoué.

ça marche pour moi:

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

pour trouver qu'un élément particulier est présent ou non, nous devons utiliser la méthode findElements() au lieu 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");

ça marche pour moi.. suggérez-moi si je me trompe..

Cela devrait le faire:

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

vous pouvez essayer l'attente implicite: '

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

"

Ou Vous pouvez essayer explicite attendre: `

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

"

explicite vérifiera si element est présent avant quelque action. L'attente implicite pourrait être appelée partout dans le code. Par exemple après quelques actions AJAX.

vous pouvez en trouver plus à la page SeleniumHQ: http://docs.seleniumhq.org/docs/04_webdriver_advanced.jsp

donnant mon code. Ainsi, la méthode ci-dessous vérifie si un élément web aléatoire ' crée une nouvelle Application ' bouton existe sur une page ou non. Notez que j'ai utilisé la période d'attente comme 0 secondes.

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

j'utiliserais quelque chose comme (avec Scala [le code dans le bon vieux Java 8 peut être similaire à ceci]):

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

alors,

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

la manière la plus simple que J'ai trouvée en Java est:

List<WebElement> 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();
    }

Voici des façons de vérifier si un élément Web isPresent ou n'est pas :

j'ai utilisé XPath comme élément identifiant/Localisateur , mais vous pouvez également utiliser d'autres localisateurs.

Solution I:

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

Solution II:

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

Solution III:

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

personnellement, j'opte toujours pour un mélange des réponses ci-dessus et crée une méthode D'utilité statique réutilisable qui utilise la taille () < 0 suggestion:

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

c'est soigné, réutilisable, maintenable ... toutes ces bonnes choses ;-)