Le sélénium c# Webdriver: Attendre Jusqu'à ce que l'Élément est Présent

Alternativement, vous pouvez utiliser implicite attendre:

driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(10);

Implicite de l'attendre, c'est à dire WebDriver pour interroger les DOM pour un certain
quantité de temps à essayer de trouver un élément ou des éléments s'ils sont
pas immédiatement disponibles. Le réglage par défaut est de 0. Une fois réglé, le
implicite d'attente est fixé pour la durée de vie de la WebDriver instance de l'objet.

Vous pouvez également utiliser

ExpectedConditions.ElementExists

De sorte que vous sera la recherche d'un élément de disponibilité comme ça

new WebDriverWait(driver, TimeSpan.FromSeconds(timeOut)).Until(ExpectedConditions.ElementExists((By.Id(login))));

Source

Inspiré par Loudenvier de la solution, voici une méthode d'extension qui fonctionne pour tous les ISearchContext objets, pas seulement IWebDriver, qui est une spécialisation de l'ancien. Cette méthode prend également en charge d'attente jusqu'à ce que l'élément est affiché.

static class WebDriverExtensions
{
    ///<summary>
    ///Find an element, waiting until a timeout is reached if necessary.
    ///</summary>
    ///<param name="context">The search context.</param>
    ///<param name="by">Method to find elements.</param>
    ///<param name="timeout">How many seconds to wait.</param>
    ///<param name="displayed">Require the element to be displayed?</param>
    ///<returns>The found element.</returns>
    public static IWebElement FindElement(this ISearchContext context, By by, uint timeout, bool displayed=false)
    {
        var wait = new DefaultWait<ISearchContext>(context);
        wait.Timeout = TimeSpan.FromSeconds(timeout);
        wait.IgnoreExceptionTypes(typeof(NoSuchElementException));
        return wait.Until(ctx => {
            var elem = ctx.FindElement(by);
            if (displayed && !elem.Displayed)
                return null;

            return elem;
        });
    }
}

Exemple d'utilisation:

var driver = new FirefoxDriver();
driver.Navigate().GoToUrl("http://localhost");
var main = driver.FindElement(By.Id("main"));
var btn = main.FindElement(By.Id("button"));
btn.Click();
var dialog = main.FindElement(By.Id("dialog"), 5, displayed: true);
Assert.AreEqual("My Dialog", dialog.Text);
driver.Close();

Vous pouvez trouver quelque chose comme ça en C# .

C'est ce que j'ai utilisé dans JUnit - Sélénium

WebDriverWait wait = new WebDriverWait(driver, 100);
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.id("submit")));

Faire importer des paquets liés

Python:

from selenium import webdriver
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.common.by import By

driver.find_element_by_id('someId').click()

WebDriverWait(driver, timeout).until(EC.presence_of_element_located((By.ID, 'someAnotherId'))

de CE que vous pouvez choisir d'autres conditions ainsi
essayez ceci: http://selenium-python.readthedocs.org/api.html#module-selenium.webdriver.support.expected_conditions

Essayez ce code:

 New WebDriverWait(driver, TimeSpan.FromSeconds(10)).Until(Function(d) d.FindElement(By.Id("controlName")).Displayed)

public bool doesWebElementExist(string linkexist)
{
     try
     {
        driver.FindElement(By.XPath(linkexist));
        return true;
     }
     catch (NoSuchElementException e)
     {
        return false;
     }
}

Depuis que je suis séparer les éléments de la page de définitions et de la page de test à l'aide de scénarios déjà trouvé IWebElement pour la visibilité pourrait être fait comme ceci:

public static void WaitForElementToBecomeVisibleWithinTimeout(IWebDriver driver, IWebElement element, int timeout)
{
    new WebDriverWait(driver, TimeSpan.FromSeconds(timeout)).Until(ElementIsVisible(element));
}

private static Func<IWebDriver, bool> ElementIsVisible(IWebElement element)
{
    return driver => {
        try
        {
            return element.Displayed;              
        }
        catch(Exception)
        {
            //If element is null, stale or if it cannot be located
            return false;
        }
    };
}

Utilisé Rn222 et Aknuds1 d'utiliser un ISearchContext qui renvoie à un élément ou une liste. Et un nombre minimum d'éléments peuvent être spécifiés:

public static class SearchContextExtensions
{
///<summary>
///    Method that finds an element based on the search parameters within a specified timeout.
///</summary>
///<param name="context">The context where this is searched. Required for extension methods</param>
///<param name="by">The search parameters that are used to identify the element</param>
///<param name="timeOutInSeconds">The time that the tool should wait before throwing an exception</param>
///<returns> The first element found that matches the condition specified</returns>
public static IWebElement FindElement(this ISearchContext context, By by, uint timeOutInSeconds)
{
if (timeOutInSeconds > 0)
{
var wait = new DefaultWait<ISearchContext>(context);
wait.Timeout = TimeSpan.FromSeconds(timeOutInSeconds);
return wait.Until<IWebElement>(ctx => ctx.FindElement(by));
}
return context.FindElement(by);
}
///<summary>
///    Method that finds a list of elements based on the search parameters within a specified timeout.
///</summary>
///<param name="context">The context where this is searched. Required for extension methods</param>
///<param name="by">The search parameters that are used to identify the element</param>
///<param name="timeoutInSeconds">The time that the tool should wait before throwing an exception</param>
///<returns>A list of all the web elements that match the condition specified</returns>
public static IReadOnlyCollection<IWebElement> FindElements(this ISearchContext context, By by, uint timeoutInSeconds)
{
if (timeoutInSeconds > 0)
{
var wait = new DefaultWait<ISearchContext>(context);
wait.Timeout = TimeSpan.FromSeconds(timeoutInSeconds);
return wait.Until<IReadOnlyCollection<IWebElement>>(ctx => ctx.FindElements(by));
}
return context.FindElements(by);
}
///<summary>
///    Method that finds a list of elements with the minimum amount specified based on the search parameters within a specified timeout.<br/>
///</summary>
///<param name="context">The context where this is searched. Required for extension methods</param>
///<param name="by">The search parameters that are used to identify the element</param>
///<param name="timeoutInSeconds">The time that the tool should wait before throwing an exception</param>
///<param name="minNumberOfElements">
///    The minimum number of elements that should meet the criteria before returning the list <para/>
///    If this number is not met, an exception will be thrown and no elements will be returned
///    even if some did meet the criteria
///</param>
///<returns>A list of all the web elements that match the condition specified</returns>
public static IReadOnlyCollection<IWebElement> FindElements(this ISearchContext context, By by, uint timeoutInSeconds, int minNumberOfElements)
{
var wait = new DefaultWait<ISearchContext>(context);
if (timeoutInSeconds > 0)
{
wait.Timeout = TimeSpan.FromSeconds(timeoutInSeconds);
}
//Wait until the current context found the minimum number of elements. If not found after timeout, an exception is thrown
wait.Until<bool>(ctx => ctx.FindElements(by).Count >= minNumberOfElements);
//If the elements were successfuly found, just return the list
return context.FindElements(by);
}
}

Exemple d'utilisation:

var driver = new FirefoxDriver();
driver.Navigate().GoToUrl("http://localhost");
var main = driver.FindElement(By.Id("main"));
//It can be now used to wait when using elements to search
var btn = main.FindElement(By.Id("button"),10);
btn.Click();
//This will wait up to 10 seconds until a button is found
var button = driver.FindElement(By.TagName("button"),10)
//This will wait up to 10 seconds until a button is found, and return all the buttons found
var buttonList = driver.FindElements(By.TagName("button"),10)
//This will wait for 10 seconds until we find at least 5 buttons
var buttonsMin= driver.FindElements(By.TagName("button"), 10, 5);
driver.Close();

Nous pouvons réaliser que comme ceci:

public static IWebElement WaitForObject(IWebDriver DriverObj, By by, int TimeOut = 30)
{
try
{
WebDriverWait Wait1 = new WebDriverWait(DriverObj, TimeSpan.FromSeconds(TimeOut));
var WaitS = Wait1.Until(SeleniumExtras.WaitHelpers.ExpectedConditions.PresenceOfAllElementsLocatedBy(by));
return WaitS[0];
}
catch (NoSuchElementException)
{
Reports.TestStep("Wait for Element(s) with xPath was failed in current context page.");
throw;
}
}

Était à la recherche d'attendre en Sélénium de l'état, a atterri dans ce fil, et voici ce que j'utilise maintenant:

    WebDriverWait wait = new WebDriverWait(m_driver, TimeSpan.FromSeconds(10));
wait.Until(d => ReadCell(row, col) != "");

ReadCell(row, col) != "" peut être n'importe quelle condition. Comme de cette façon parce que:

• c'est le mien
• permet d'inlining

Première réponse est la bonne, mon problème était que les exceptions non gérées ne pas fermer web pilote correctement et elle a toujours la même valeur, j'avais utilisé ce qui était de 1 seconde.

Si vous obtenez le même problème

restart you visual studio et de s'assurer que all the exceptions are handled correctement.