Comment attendre jusqu'à ce qu'un élément n'existe plus dans Selenium

Je suis en train de tester une INTERFACE utilisateur dans laquelle l'utilisateur clique sur un bouton de suppression et d'une entrée de la table disparaît. En tant que tel, je veux être en mesure de vérifier que l'entrée de la table n'existe plus.

J'ai essayé d'utiliser ExpectedConditions.not() pour inverser ExpectedConditions.presenceOfElementLocated()en espérant que cela voudrait dire "s'attendre à ce que il n'y a pas une présence de l'élément spécifié". Mon code est comme suit:

browser.navigate().to("http://stackoverflow.com");
new WebDriverWait(browser, 1).until(
        ExpectedConditions.not(
                ExpectedConditions.presenceOfElementLocated(By.id("foo"))));

Cependant, j'ai trouvé que même en faisant ceci, j'obtiens un TimeoutExpcetion causée par un NoSuchElementException dire que l'élément "toto" n'existe pas. Bien sûr, n'ayant pas un tel élément est ce que je veux, mais je ne veux pas la levée d'une exception.

Alors, comment puis-je attendre jusqu'à ce qu'un élément n'existe plus? Je préfère un exemple qui ne dépend pas de l'interception d'une exception, si c'est possible (ce que je comprends, des exceptions doivent être levées exceptionnelles comportement).

source d'informationauteur Thunderforge

  1. 31

    Vous pouvez également utiliser - 

    new WebDriverWait(driver, 10).until(ExpectedConditions.invisibilityOfElementLocated(locator));

    Si vous allez par le biais de la source de celui-ci, vous pouvez voir que les deux NoSuchElementException et staleElementReferenceException sont traitées.

    /**
   * An expectation for checking that an element is either invisible or not
   * present on the DOM.
   *
   * @param locator used to find the element
   */
  public static ExpectedCondition<Boolean> invisibilityOfElementLocated(
      final By locator) {
    return new ExpectedCondition<Boolean>() {
      @Override
      public Boolean apply(WebDriver driver) {
        try {
          return !(findElement(locator, driver).isDisplayed());
        } catch (NoSuchElementException e) {
          //Returns true because the element is not present in DOM. The
          //try block checks if the element is present but is invisible.
          return true;
        } catch (StaleElementReferenceException e) {
          //Returns true because stale element reference implies that element
          //is no longer visible.
          return true;
        }
      }
  2. 4

    La solution serait toujours compter sur la gestion des exceptions. Et c'est à peu près ok, même standard Conditions prévues s'appuyer sur l'exception levée par findElement().

    L'idée est de créer un personnalisé Condition Attendue:

      public static ExpectedCondition<Boolean> absenceOfElementLocated(
      final By locator) {
    return new ExpectedCondition<Boolean>() {
      @Override
      public Boolean apply(WebDriver driver) {
        try {
          driver.findElement(locator);
          return false;
        } catch (NoSuchElementException e) {
          return true;
        } catch (StaleElementReferenceException e) {
          return true;
        }
      }

      @Override
      public String toString() {
        return "element to not being present: " + locator;
      }
    };
  }
  3. 1

    Pourquoi ne pas simplement de trouver la taille de elements. Nous savons que la collecte d'éléments taille serait 0 si élément n'existe pas.

    if(driver.findElements(By.id("foo").size() > 0 ){
    //It should fail
}else{
    //pass
}
  4. 0
    //pseudo code
public Fun<driver,webelement> ElemtDisappear(locator)
{
    webelement element=null;
    iList<webelement> elemt =null;
    return driver=>
    {
    try
    {
    elemt = driver.findelements(By.locator);
    if(elemt.count!=0)
    {
    element=driver.findelement(By.locator);
    }
    }
    catch(Exception e)
    {
    }
    return(elemnt==0)?element:null;
};

//call function
public void waitforelemDiappear(driver,locator)
{
    webdriverwaiter wait = new webdriverwaiter(driver,time);
    try
    {
    wait.until(ElemtDisappear(locator));
    }
    catch(Exception e)
    {
    }
}

    Comme findelement throws exception sur l'élément unaviability.j'ai donc mis en œuvre à l'aide de findelements. n'hésitez pas à les corriger et de les utiliser selon votre besoin.

  5. 0

    J'ai trouvé une solution de contournement pour résoudre ce problème pour moi de manière efficace, utilisée à la suite de code C# pour gérer cela, vous pouvez convertir en Java

        public bool WaitForElementDisapper(By element)
    {
        try
        {
            while (true)
            {
                try
                {
                    if (driver.FindElement(element).Displayed)
                        Thread.Sleep(2000);
                }
                catch (NoSuchElementException)
                {
                    break;
                }
            }
            return true;
        }
        catch (Exception e)
        {
            logger.Error(e.Message);
            return false;
        }
    }