Selenium attend que le document soit prêt

Quelqu'un peut-il me dire comment puis-je faire attendre le sélénium jusqu'à ce que la page se charge complètement? Je veux quelque chose de générique, je sais que je peux configurer WebDriverWait et appeler quelque chose comme «trouver» pour le faire attendre mais je ne vais pas aussi loin. J'ai juste besoin de tester que la page se charge correctement et de passer à la page suivante pour tester.

J'ai trouvé quelque chose dans .net mais je n'ai pas pu le faire fonctionner en java ...

IWait<IWebDriver> wait = new OpenQA.Selenium.Support.UI.WebDriverWait(driver, TimeSpan.FromSeconds(30.00));
wait.Until(driver1 => ((IJavaScriptExecutor)driver).ExecuteScript("return document.readyState").Equals("complete"));

Des pensées quelqu'un?

Essayez ce code:

  driver.manage().timeouts().pageLoadTimeout(10, TimeUnit.SECONDS);

Le code ci-dessus attendra jusqu'à 10 secondes pour le chargement de la page. Si le chargement de la page dépasse le temps, le fichier TimeoutException. Vous attrapez l'exception et faites vos besoins. Je ne sais pas si cela arrête le chargement de la page après l'exception levée. je n'ai pas encore essayé ce code. Je veux juste l'essayer.

C'est une attente implicite. Si vous le définissez une fois, il aura l'étendue jusqu'à ce que l'instance du pilote Web soit détruite.

Consultez la documentationWebDriver.Timeouts pour plus d'informations.

La solution que vous suggérez n'attend que le signal du DOMreadyStatecomplete . Mais Selenium essaie par défaut d'attendre ceux (et un peu plus) lors des chargements de page via les méthodes driver.get()et element.click(). Ils bloquent déjà, ils attendent que la page se charge complètement et ceux-ci devraient fonctionner correctement.

Le problème, évidemment, sont les redirections via des requêtes AJAX et des scripts en cours d'exécution - ceux-ci ne peuvent pas être capturés par Selenium, il n'attend pas qu'ils se terminent. De plus, vous ne pouvez pas les attraper de manière fiable via readyState- cela attend un peu, ce qui peut être utile, mais cela signalera completelongtemps avant que tout le contenu AJAX ne soit téléchargé.

Il n'y a pas de solution générale qui fonctionnerait partout et pour tout le monde, c'est pourquoi c'est difficile et tout le monde utilise quelque chose d'un peu différent.

La règle générale est de s'appuyer sur WebDriver pour faire sa part, puis d'utiliser des attentes implicites, puis d'utiliser des attentes explicites pour les éléments que vous souhaitez affirmer sur la page, mais il y a beaucoup plus de techniques qui peuvent être faites. Vous devez choisir celui (ou une combinaison de plusieurs d'entre eux) qui fonctionne le mieux dans votre cas, sur votre page testée.

Voir mes deux réponses à ce sujet pour plus d'informations:

• Comment puis-je vérifier si la page est complètement chargée ou non dans le pilote Web
• Selenium Webdriver: attendez le chargement d'une page complexe avec JavaScript

Ceci est une version Java fonctionnelle de l'exemple que vous avez donné:

void waitForLoad(WebDriver driver) {
    new WebDriverWait(driver, 30).until((ExpectedCondition<Boolean>) wd ->
            ((JavascriptExecutor) wd).executeScript("return document.readyState").equals("complete"));
}

Exemple pour c #:

public static void WaitForLoad(IWebDriver driver, int timeoutSec = 15)
{
  IJavaScriptExecutor js = (IJavaScriptExecutor)driver;
  WebDriverWait wait = new WebDriverWait(driver, new TimeSpan(0, 0, timeoutSec));
  wait.Until(wd => js.ExecuteScript("return document.readyState").ToString() == "complete");
}

Voici ma tentative d'une solution complètement générique, en Python:

Tout d'abord, une fonction générique "wait" (utilisez un WebDriverWait si vous le souhaitez, je les trouve moche):

def wait_for(condition_function):
    start_time = time.time()
    while time.time() < start_time + 3:
        if condition_function():
            return True
        else:
            time.sleep(0.1)
    raise Exception('Timeout waiting for {}'.format(condition_function.__name__))

Ensuite, la solution repose sur le fait que le sélénium enregistre un numéro d'identification (interne) pour tous les éléments d'une page, y compris l' <html>élément de niveau supérieur . Lorsqu'une page s'actualise ou se charge, elle obtient un nouvel élément html avec un nouvel ID.

Donc, en supposant que vous vouliez cliquer sur un lien avec le texte "mon lien" par exemple:

old_page = browser.find_element_by_tag_name('html')

browser.find_element_by_link_text('my link').click()

def page_has_loaded():
    new_page = browser.find_element_by_tag_name('html')
    return new_page.id != old_page.id

wait_for(page_has_loaded)

Pour plus d'aide pythonique, réutilisable et générique, vous pouvez créer un gestionnaire de contexte:

from contextlib import contextmanager

@contextmanager
def wait_for_page_load(browser):
    old_page = browser.find_element_by_tag_name('html')

    yield

    def page_has_loaded():
        new_page = browser.find_element_by_tag_name('html')
        return new_page.id != old_page.id

    wait_for(page_has_loaded)

Et puis vous pouvez l'utiliser sur à peu près n'importe quelle interaction de sélénium:

with wait_for_page_load(browser):
    browser.find_element_by_link_text('my link').click()

Je pense que c'est à l'épreuve des balles! Qu'est-ce que tu penses?

Plus d'informations dans un article de blog à ce sujet ici

J'avais un problème similaire. J'avais besoin d'attendre que mon document soit prêt mais aussi que tous les appels Ajax soient terminés. La deuxième condition s'est avérée difficile à détecter. En fin de compte, j'ai vérifié les appels Ajax actifs et cela a fonctionné.

Javascript:

return (document.readyState == 'complete' && jQuery.active == 0)

Méthode C # complète:

private void WaitUntilDocumentIsReady(TimeSpan timeout)
{
    var javaScriptExecutor = WebDriver as IJavaScriptExecutor;
    var wait = new WebDriverWait(WebDriver, timeout);            

    // Check if document is ready
    Func<IWebDriver, bool> readyCondition = webDriver => javaScriptExecutor
        .ExecuteScript("return (document.readyState == 'complete' && jQuery.active == 0)");
    wait.Until(readyCondition);
}

WebDriverWait wait = new WebDriverWait(dr, 30);
wait.until(ExpectedConditions.jsReturnsValue("return document.readyState==\"complete\";"));

Pour C # NUnit, vous devez convertir WebDriver en JSExecuter, puis exécuter le script pour vérifier si l'état de document.ready est complet ou non. Vérifiez le code ci-dessous pour référence:

 public static void WaitForLoad(IWebDriver driver)
    {
        IJavaScriptExecutor js = (IJavaScriptExecutor)driver;
        int timeoutSec = 15;
        WebDriverWait wait = new WebDriverWait(driver, new TimeSpan(0, 0, timeoutSec));
        wait.Until(wd => js.ExecuteScript("return document.readyState").ToString() == "complete");
    }

Cela attendra que la condition soit satisfaite ou que le délai expire.

Pour le chargement initial de la page, j'ai remarqué que "Maximiser" la fenêtre du navigateur attend pratiquement que le chargement de la page soit terminé (y compris les sources)

Remplacer:

AppDriver.Navigate().GoToUrl(url);

Avec:

public void OpenURL(IWebDriver AppDriver, string Url)
            {
                try
                {
                    AppDriver.Navigate().GoToUrl(Url);
                    AppDriver.Manage().Window.Maximize();
                    AppDriver.SwitchTo().ActiveElement();
                }
                catch (Exception e)
                {
                    Console.WriteLine("ERR: {0}; {1}", e.TargetSite, e.Message);
                    throw;
                }
            }

que d'utiliser:

OpenURL(myDriver, myUrl);

Cela chargera la page, attendra qu'elle soit terminée, l'agrandira et se concentrera dessus. Je ne sais pas pourquoi c'est comme ça mais ça marche.

Si vous voulez attendre le chargement de la page après avoir cliqué sur suivant ou sur tout autre déclencheur de navigation de page autre que "Naviguer ()", la réponse de Ben Dyer (dans ce fil) fera le travail.

Jetez un œil au framework web tapestry . Vous pouvez y télécharger le code source .

L'idée est de signaler que la page est prête par l'attribut html du corps. Vous pouvez utiliser cette idée pour ignorer les cas de poursuites compliqués.

<html>
<head>
</head>
<body data-page-initialized="false">
    <p>Write you page here</p>

    <script>
    $(document).ready(function () {
        $(document.body).attr('data-page-initialized', 'true');
    });
    </script>  
</body>
</html>

Et puis créer une extension de Selenium webdriver (selon le framework tapestry)

public static void WaitForPageToLoad(this IWebDriver driver, int timeout = 15000)
{
    //wait a bit for the page to start loading
    Thread.Sleep(100);

    //// In a limited number of cases, a "page" is an container error page or raw HTML content
    // that does not include the body element and data-page-initialized element. In those cases,
    // there will never be page initialization in the Tapestry sense and we return immediately.
    if (!driver.ElementIsDisplayed("/html/body[@data-page-initialized]"))
    {                
        return;
    }

    Stopwatch stopwatch = Stopwatch.StartNew();

    int sleepTime = 20;

    while(true)
    {
        if (driver.ElementIsDisplayed("/html/body[@data-page-initialized='true']"))
        {
            return;
        }

        if (stopwatch.ElapsedMilliseconds > 30000)
        {
            throw new Exception("Page did not finish initializing after 30 seconds.");
        }

        Thread.Sleep(sleepTime);
        sleepTime *= 2; // geometric row of sleep time
    }          
}

Utilisez l'extension ElementIsDisplayed écrite par Alister Scott .

public static bool ElementIsDisplayed(this IWebDriver driver, string xpath)
{
    try
    {
        return driver.FindElement(By.XPath(xpath)).Displayed;
    }
    catch(NoSuchElementException)
    {
        return false;
    }
}

Et enfin créer un test:

driver.Url = this.GetAbsoluteUrl("/Account/Login");            
driver.WaitForPageToLoad();

La réponse de Ben Dryer n'a pas été compilée sur ma machine ( "The method until(Predicate<WebDriver>) is ambiguous for the type WebDriverWait").

Version de travail de Java 8:

Predicate<WebDriver> pageLoaded = wd -> ((JavascriptExecutor) wd).executeScript(
        "return document.readyState").equals("complete");
new FluentWait<WebDriver>(driver).until(pageLoaded);

Version Java 7:

Predicate<WebDriver> pageLoaded = new Predicate<WebDriver>() {

        @Override
        public boolean apply(WebDriver input) {
            return ((JavascriptExecutor) input).executeScript("return document.readyState").equals("complete");
        }

};
new FluentWait<WebDriver>(driver).until(pageLoaded);

J'ai essayé ce code et cela fonctionne pour moi. J'appelle cette fonction chaque fois que je passe à une autre page

public static void waitForPageToBeReady() 
{
    JavascriptExecutor js = (JavascriptExecutor)driver;

    //This loop will rotate for 100 times to check If page Is ready after every 1 second.
    //You can replace your if you wants to Increase or decrease wait time.
    for (int i=0; i<400; i++)
    { 
        try 
        {
            Thread.sleep(1000);
        }catch (InterruptedException e) {} 
        //To check page ready state.

        if (js.executeScript("return document.readyState").toString().equals("complete"))
        { 
            break; 
        }   
      }
 }

Dans Nodejs, vous pouvez l'obtenir via des promesses ...

Si vous écrivez ce code, vous pouvez être sûr que la page est complètement chargée lorsque vous arrivez à alors ...

driver.get('www.sidanmor.com').then(()=> {
    // here the page is fully loaded!!!
    // do your stuff...
}).catch(console.log.bind(console));

Si vous écrivez ce code, vous naviguerez, et le sélénium attendra 3 secondes ...

driver.get('www.sidanmor.com');
driver.sleep(3000);
// you can't be sure that the page is fully loaded!!!
// do your stuff... hope it will be OK...

À partir de la documentation Selenium:

this.get (url) → Thenable

Planifie une commande pour accéder à l'URL donnée.

Renvoie une promesse qui sera résolue une fois le chargement du document terminé .

Documentation Selenium (Nodejs)

L'attente de l'événement document.ready n'est pas la solution complète à ce problème, car ce code est toujours dans une condition de concurrence: parfois, ce code est déclenché avant le traitement de l'événement de clic, donc cela retourne directement, car le navigateur n'a pas démarré chargement de la nouvelle page pour le moment.

Après quelques recherches, j'ai trouvé un article sur Obay, la chèvre de test , qui a une solution à ce problème. Le code c # pour cette solution est quelque chose comme ceci:

 IWebElement page = null;
 ...
 public void WaitForPageLoad()
 {
    if (page != null)
    {
       var waitForCurrentPageToStale = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
       waitForCurrentPageToStale.Until(ExpectedConditions.StalenessOf(page));
    }

    var waitForDocumentReady = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
    waitForDocumentReady.Until((wdriver) => (driver as IJavaScriptExecutor).ExecuteScript("return document.readyState").Equals("complete"));

    page = driver.FindElement(By.TagName("html"));

}

`Je lance cette méthode directement après le driver.navigate.gotourl, afin qu'il obtienne une référence de la page dès que possible. Aie du plaisir avec ça!

Normalement, lorsque le sélénium ouvre une nouvelle page à partir d'un clic ou soumet ou récupère des méthodes, il attendra que la page soit chargée, mais le problème est que lorsque la page a un appel xhr (ajax), il n'attendra jamais que le xhr soit chargé, donc créer une nouvelle méthode pour surveiller un xhr et les attendre, ce sera le bien.

public boolean waitForJSandJQueryToLoad() {
    WebDriverWait wait = new WebDriverWait(webDriver, 30);
    // wait for jQuery to load
    ExpectedCondition<Boolean> jQueryLoad = new ExpectedCondition<Boolean>() {
      @Override
      public Boolean apply(WebDriver driver) {
        try {
            Long r = (Long)((JavascriptExecutor)driver).executeScript("return $.active");
            return r == 0;
        } catch (Exception e) {
            LOG.info("no jquery present");
            return true;
        }
      }
    };

    // wait for Javascript to load
    ExpectedCondition<Boolean> jsLoad = new ExpectedCondition<Boolean>() {
      @Override
      public Boolean apply(WebDriver driver) {
        return ((JavascriptExecutor)driver).executeScript("return document.readyState")
        .toString().equals("complete");
      }
    };

  return wait.until(jQueryLoad) && wait.until(jsLoad);
}

if $.active == 0il n'y a donc pas d'appel xhrs actif (qui ne fonctionne qu'avec jQuery). pour l'appel javascript ajax, vous devez créer une variable dans votre projet et la simuler.

Vous pouvez écrire une logique pour gérer cela. J'ai écrit une méthode qui renverra le WebElementet cette méthode sera appelée trois fois ou vous pouvez augmenter le temps et ajouter une vérification nulle pour WebElementVoici un exemple

public static void main(String[] args) {
        WebDriver driver = new FirefoxDriver();
        driver.get("https://www.crowdanalytix.com/#home");
        WebElement webElement = getWebElement(driver, "homekkkkkkkkkkkk");
        int i = 1;
        while (webElement == null && i < 4) {
            webElement = getWebElement(driver, "homessssssssssss");
            System.out.println("calling");
            i++;
        }
        System.out.println(webElement.getTagName());
        System.out.println("End");
        driver.close();
    }

    public static WebElement getWebElement(WebDriver driver, String id) {
        WebElement myDynamicElement = null;
        try {
            myDynamicElement = (new WebDriverWait(driver, 10))
                    .until(ExpectedConditions.presenceOfElementLocated(By
                            .id(id)));
            return myDynamicElement;
        } catch (TimeoutException ex) {
            return null;
        }
    }

J'ai exécuté un code javascript pour vérifier si le document est prêt. Cela m'a fait gagner beaucoup de temps en déboguant les tests de sélénium pour les sites qui ont un rendu côté client.

public static boolean waitUntilDOMIsReady(WebDriver driver) {
def maxSeconds = DEFAULT_WAIT_SECONDS * 10
for (count in 1..maxSeconds) {
    Thread.sleep(100)
    def ready = isDOMReady(driver);
    if (ready) {
        break;
    }
}

}

public static boolean isDOMReady(WebDriver driver){
    return driver.executeScript("return document.readyState");
}

public boolean waitForElement(String zoneName, String element, int index, int timeout) {
        WebDriverWait wait = new WebDriverWait(appiumDriver, timeout/1000);
        wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath(element)));
        return true;
    }

Comme Rubanov a écrit pour C #, je l'écris pour Java, et c'est:

    public void waitForPageLoaded() {
    ExpectedCondition<Boolean> expectation = new
            ExpectedCondition<Boolean>() {
                public Boolean apply(WebDriver driver) {
                    return (((JavascriptExecutor) driver).executeScript("return document.readyState").toString().equals("complete")&&((Boolean)((JavascriptExecutor)driver).executeScript("return jQuery.active == 0")));
                }
            };
    try {
        Thread.sleep(100);
        WebDriverWait waitForLoad = new WebDriverWait(driver, 30);
        waitForLoad.until(expectation);
    } catch (Throwable error) {
        Assert.fail("Timeout waiting for Page Load Request to complete.");
    }
}

En Java, ce sera comme ci-dessous: -

  private static boolean isloadComplete(WebDriver driver)
    {
        return ((JavascriptExecutor) driver).executeScript("return document.readyState").equals("loaded")
                || ((JavascriptExecutor) driver).executeScript("return document.readyState").equals("complete");
    }

Le code suivant devrait probablement fonctionner:

WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.presenceOfAllElementsLocated(By.xpath("//*")));

Si votre page ou votre connexion réseau est lente, il est probable qu'aucune des solutions ci-dessus ne fonctionnera. Je les ai tous essayés et la seule chose qui a fonctionné pour moi est d'attendre le dernier élément visible sur cette page. Prenons par exemple la page Web Bing. Ils ont placé une icône CAMERA (bouton de recherche par image) à côté du bouton de recherche principal qui n'est visible qu'après le chargement de la page complète. Si tout le monde a fait cela, alors tout ce que nous avons à faire est d'utiliser une attente explicite comme dans les exemples ci-dessus.

public void waitForPageToLoad()
  {
(new WebDriverWait(driver, DEFAULT_WAIT_TIME)).until(new ExpectedCondition<Boolean>() {
      public Boolean apply(WebDriver d) {
        return (((org.openqa.selenium.JavascriptExecutor) driver).executeScript("return document.readyState").equals("complete"));
      }
    });//Here DEFAULT_WAIT_TIME is a integer correspond to wait time in seconds

Voici quelque chose de similaire, dans Ruby:

wait = Selenium::WebDriver::Wait.new(:timeout => 10)
wait.until { @driver.execute_script('return document.readyState').eql?('complete') }

Vous pouvez faire dormir le fil jusqu'à ce que la page soit rechargée. Ce n'est pas la meilleure solution, car vous devez avoir une estimation du temps de chargement de la page.

driver.get(homeUrl); 
Thread.sleep(5000);
driver.findElement(By.xpath("Your_Xpath_here")).sendKeys(userName);
driver.findElement(By.xpath("Your_Xpath_here")).sendKeys(passWord);
driver.findElement(By.xpath("Your_Xpath_here")).click();

J'ai vérifié que le chargement de la page était terminé, je travaille dans Selenium 3.14.0

    public static void UntilPageLoadComplete(IWebDriver driver, long timeoutInSeconds)
    {
        Until(driver, (d) =>
        {
            Boolean isPageLoaded = (Boolean)((IJavaScriptExecutor)driver).ExecuteScript("return document.readyState").Equals("complete");
            if (!isPageLoaded) Console.WriteLine("Document is loading");
            return isPageLoaded;
        }, timeoutInSeconds);
    }

    public static void Until(IWebDriver driver, Func<IWebDriver, Boolean> waitCondition, long timeoutInSeconds)
    {
        WebDriverWait webDriverWait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
        webDriverWait.Timeout = TimeSpan.FromSeconds(timeoutInSeconds);
        try
        {
            webDriverWait.Until(waitCondition);
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
    }

Pour les personnes qui ont besoin d'attendre qu'un élément spécifique apparaisse. (utilisé c #)

public static void WaitForElement(IWebDriver driver, By element)
{
    WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(20));
    wait.Until(ExpectedConditions.ElementIsVisible(element));
}

Ensuite, si vous voulez attendre par exemple si un class = "error-message" existe dans le DOM, vous faites simplement:

WaitForElement(driver, By.ClassName("error-message"));

Pour id, ce sera alors

WaitForElement(driver, By.Id("yourid"));

Utilisez-vous Angular? Si c'est le cas, il est possible que le pilote Web ne reconnaisse pas que les appels asynchrones sont terminés.

Je recommande de regarder Paul Hammants ngWebDriver . La méthode waitForAngularRequestsToFinish () pourrait être utile.