Attendre le chargement de la page dans Selenium
Comment faites-vous Selenium 2.0 attendre le chargement de la page?
Vous pouvez également vérifier pageloaded en utilisant le code suivant
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"));
Utilisez la classe WebDriverWait
Voir aussi ici
Vous pouvez vous attendre à montrer certains éléments. quelque chose comme en C #:
WebDriver _driver = new WebDriver();
WebDriverWait _wait = new WebDriverWait(_driver, new TimeSpan(0, 1, 0));
_wait.Until(d => d.FindElement(By.Id("Id_Your_UIElement"));
Si vous définissez l'attente implicite du pilote, puis appelez la méthode findElement sur un élément que vous attendez sur la page chargée, WebDriver interrogera cet élément jusqu'à ce qu'il le trouve ou atteigne la valeur de délai d'attente.
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
source: implicite-attend
En général, avec Selenium 2.0, le pilote Web ne doit rendre le contrôle au code de l'appelant qu'une fois qu'il a déterminé que la page a été chargée. Si ce n'est pas le cas, vous pouvez appeler waitforelemement, qui effectue un cycle successif en appelant findelement jusqu'à ce qu'il soit trouvé ou expire (le délai peut être défini).
Ruby implémentation:
wait = Selenium::WebDriver::Wait.new(:timeout => 10)
wait.until {
@driver.execute_script("return document.readyState;") == "complete"
}
Vous pouvez supprimer la ligne System.out. Il est ajouté à des fins de débogage.
WebDriver driver_;
public void waitForPageLoad() {
Wait<WebDriver> wait = new WebDriverWait(driver_, 30);
wait.until(new Function<WebDriver, Boolean>() {
public Boolean apply(WebDriver driver) {
System.out.println("Current Window State : "
+ String.valueOf(((JavascriptExecutor) driver).executeScript("return document.readyState")));
return String
.valueOf(((JavascriptExecutor) driver).executeScript("return document.readyState"))
.equals("complete");
}
});
}
Toutes ces solutions sont acceptables pour des cas spécifiques, mais elles présentent au moins un ou deux problèmes possibles:
Ils ne sont pas assez génériques - ils veulent que vous sachiez à l'avance qu'une condition spécifique sera vraie pour la page que vous allez consulter (par exemple, un élément sera affiché)
Ils sont ouverts à une situation de concurrence critique dans laquelle vous utilisez un élément réellement présent sur l'ancienne page ainsi que sur la nouvelle page.
Voici ma tentative d'une solution générique qui évite ce problème (en Python):
Premièrement, une fonction générique "wait" (utilisez un WebDriverWait si vous voulez, je les trouve laids):
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 Selenium enregistre un numéro d'identification (interne) pour tous les éléments d'une page, y compris l'élément <html> de niveau supérieur. Lorsqu'une page est actualisée ou chargée, elle obtient un nouvel élément HTML avec un nouvel ID.
Donc, si vous voulez 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’aides génériques réutilisables Pythonic, 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 toutes les interactions de sélénium:
with wait_for_page_load(browser):
browser.find_element_by_link_text('my link').click()
Je pense que c'est pare-balles! Qu'est-ce que tu penses?
Plus d'infos dans un blog à ce sujet ici
Vous pouvez également utiliser la classe: ExpectedConditions pour attendre explicitement qu'un élément apparaisse sur la page Web avant de pouvoir entreprendre une action. Actions ultérieures
Vous pouvez utiliser la classe ExpectedConditions pour déterminer si un élément est visible:
WebElement element = (new WebDriverWait(getDriver(), 10)).until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector("input#houseName")));
Voir ExpectedConditions class Javadoc pour la liste de toutes les conditions que vous pouvez vérifier.
Cela semble être une limitation sérieuse de WebDriver. Évidemment, l'attente d'un élément n'impliquera pas le chargement de la page, en particulier le DOM peut être entièrement construit (état déjà utilisé), JS étant toujours en cours d'exécution et CSS et les images restant en cours de chargement.
Je pense que la solution la plus simple consiste à définir une variable JS sur l'événement onload une fois que tout est initialisé et à vérifier et attendre cette variable JS dans Selenium.
La réponse d'Imran a été modifiée pour Java 7:
WebDriverWait wait = new WebDriverWait(driver, 30);
wait.until(new ExpectedCondition<Boolean>() {
public Boolean apply(WebDriver wdriver) {
return ((JavascriptExecutor) driver).executeScript(
"return document.readyState"
).equals("complete");
}
});
Si vous voulez attendre qu'un élément spécifique soit chargé, vous pouvez utiliser la méthode isDisplayed() sur un RenderedWebElement:
// Sleep until the div we want is visible or 5 seconds is over
long end = System.currentTimeMillis() + 5000;
while (System.currentTimeMillis() < end) {
// Browsers which render content (such as Firefox and IE) return "RenderedWebElements"
RenderedWebElement resultsDiv = (RenderedWebElement) driver.findElement(By.className("gac_m"));
// If results have been returned, the results are displayed in a drop down.
if (resultsDiv.isDisplayed()) {
break;
}
}
(Exemple de Guide de mise en route de 5 minutes )
Attendre explicitement ou attendre conditionnellement dans cette attente jusqu'à ce que cette condition soit donnée.
WebDriverWait wait = new WebDriverWait(wb, 60);
wait.until(ExpectedConditions.elementToBeClickable(By.name("value")));
Cela attendra chaque élément Web pendant 60 secondes.
Utilisez implicitement l'attente de chaque élément de la page jusqu'à l'heure indiquée.
driver.manage().timeouts().implicitlyWait(60, TimeUnit.SECONDS);
Cela attendra chaque élément Web pendant 60 secondes.
Utilisez implicitement l'attente de chaque élément de la page jusqu'à l'heure indiquée.
driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
cette attente pour chaque élément de la page pendant 30 secondes.
Une autre attente est Attente explicite ou attente conditionnelle dans cette attente jusqu'à ce que la condition soit donnée.
WebDriverWait wait = new WebDriverWait(driver, 40);
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.id("someid")));
Dans id, donnez l'élément statique id qui est affiché de manière diffidently sur la page, dès que la page est chargée.
Je suis surpris que les prédicats ne soient pas le premier choix car vous savez généralement avec quel (s) élément (s) vous allez interagir ensuite sur la page que vous attendez de charger. Mon approche a toujours été de construire des prédicats/fonctions tels que waitForElementByID(String id) et waitForElemetVisibleByClass(String className), etc. attendre sur.
Par exemple,
Dans ma classe de test:
driverWait.until(textIsPresent("expectedText");
Dans mon parent de classe de test:
protected Predicate<WebDriver> textIsPresent(String text){
final String t = text;
return new Predicate<WebDriver>(){
public boolean apply(WebDriver driver){
return isTextPresent(t);
}
};
}
protected boolean isTextPresent(String text){
return driver.getPageSource().contains(text);
}
Bien que cela semble beaucoup, il prend soin de vérifier à plusieurs reprises pour vous et l'intervalle de temps pour vérifier peut être défini avec le temps d'attente ultime avant l'expiration du délai. En outre, vous allez réutiliser de telles méthodes.
Dans cet exemple, la classe parent a défini et lancé le WebDriver driver et le WebDriverWait driverWait.
J'espère que ça aide.
Appelez ci-dessous Function dans votre script, cela attendra que la page ne soit pas chargée à l'aide de javascript
public static boolean isloadComplete(WebDriver driver)
{
return ((JavascriptExecutor) driver).executeScript("return document.readyState").equals("loaded")
|| ((JavascriptExecutor) driver).executeScript("return document.readyState").equals("complete");
}
Solution NodeJS:
Dans Nodejs , vous pouvez l'obtenir via des promesses ...
Si vous écrivez ce code, vous pouvez être sûr que la page est entièrement chargée lorsque vous arrivez à la ...
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 Selenium 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...
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é .
SeleniumWaiter:
import com.google.common.base.Function;
import org.openqa.Selenium.By;
import org.openqa.Selenium.WebDriver;
import org.openqa.Selenium.WebElement;
import org.openqa.Selenium.support.ui.WebDriverWait;
public class SeleniumWaiter {
private WebDriver driver;
public SeleniumWaiter(WebDriver driver) {
this.driver = driver;
}
public WebElement waitForMe(By locatorname, int timeout){
WebDriverWait wait = new WebDriverWait(driver, timeout);
return wait.until(SeleniumWaiter.presenceOfElementLocated(locatorname));
}
public static Function<WebDriver, WebElement> presenceOfElementLocated(final By locator) {
// TODO Auto-generated method stub
return new Function<WebDriver, WebElement>() {
@Override
public WebElement apply(WebDriver driver) {
return driver.findElement(locator);
}
};
}
}
Et à vous tilisez-le:
_waiter = new SeleniumWaiter(_driver);
try {
_waiter.waitForMe(By.xpath("//..."), 10);
}
catch (Exception e) {
// Error
}
Vous pouvez utiliser la méthode existante ci-dessous pour définir l'heure de pageeLoadTimeout dans l'exemple ci-dessous si le chargement de la page prend plus de 20 secondes, une exception de recharge de page s'affichera.
WebDriver driver = new FirefoxDriver();
driver.manage().timeouts().pageLoadTimeout(20, TimeUnit.SECONDS)
/**
* Call this method before an event that will change the page.
*/
private void beforePageLoad() {
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("document.mpPageReloaded='notYet';");
}
/**
* Call this method after an event that will change the page.
*
* @see #beforePageLoad
*
* Waits for the previous page to disappear.
*/
private void afterPageLoad() throws Exception {
(new WebDriverWait(driver, 10)).until(new Predicate<WebDriver>() {
@Override
public boolean apply(WebDriver driver) {
JavascriptExecutor js = (JavascriptExecutor) driver;
Object obj = js.executeScript("return document.mpPageReloaded;");
if (obj == null) {
return true;
}
String str = (String) obj;
if (!str.equals("notYet")) {
return true;
}
return false;
}
});
}
Vous pouvez passer du document à un élément, dans le cas où seule une partie du document est modifiée.
Cette technique a été inspirée par la réponse de Sincebasic.
Le meilleur moyen d'attendre les chargements de page lors de l'utilisation des liaisons Java pour WebDriver est d'utiliser le modèle de conception Objet de page avec PageFactory. Cela vous permet d'utiliser la AjaxElementLocatorFactory qui, pour le dire, agit simplement comme une attente globale pour tous vos éléments. Il comporte des limitations sur des éléments tels que les boîtes de dépôt ou les transitions complexes en javascript, mais il réduira considérablement la quantité de code nécessaire et accélérera les temps de test. Un bon exemple peut être trouvé dans cet article de blog. La compréhension de base de Core Java est supposée.
http://startingwithseleniumwebdriver.blogspot.ro/2015/02/wait-in-page-factory.html
Si quelqu'un utilise le séléniure:
public static final Long SHORT_WAIT = 5000L; // 5 seconds
$("some_css_selector").waitUntil(Condition.appear, SHORT_WAIT);
Plus de conditions peuvent être trouvées ici: http://selenide.org/javadoc/3.0/com/codeborne/selenide/Condition.html
Mon moyen simple:
long timeOut = 5000;
long end = System.currentTimeMillis() + timeOut;
while (System.currentTimeMillis() < end) {
if (String.valueOf(
((JavascriptExecutor) driver)
.executeScript("return document.readyState"))
.equals("complete")) {
break;
}
}
Vous pouvez utiliser attendre. il y a essentiellement 2 types d'attente dans le sélénium
- Attente implicite
- Attente explicite
- attente implicite
Ceci est très simple, veuillez voir la syntaxe ci-dessous:
driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);
- Attente explicite
Attendre explicitement ou attendre conditionnellement dans cette attente jusqu'à ce que la condition donnée soit remplie.
WebDriverWait wait = new WebDriverWait(driver, 40);
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.id("someid")));
Vous pouvez utiliser d'autres propriétés comme visblityOf(), visblityOfElement()
Dans mon cas, j’ai utilisé ce qui suit pour connaître l’état de chargement de la page. Dans notre application, les gifs de chargement sont présents et, je les écoute comme suit pour éliminer les temps d'attente non désirés dans le script.
public static void processing(){
WebDriverWait wait = new WebDriverWait(driver, 30);
wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//div[@id='Msgpanel']/div/div/img")));
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.xpath("//div[@id='Msgpanel']/div/div/img")));
}
Où xpath localise le gif dans le DOM HTML. Après cela, vous pouvez également implémenter vos méthodes d'action. Cliquez sur.
public static void click(WebElement elementToBeClicked){
WebDriverWait wait = new WebDriverWait(driver, 45);
wait.until(ExpectedConditions.visibilityOf(element));
wait.until(ExpectedConditions.elementToBeClickable(element));
wait.ignoring(NoSuchElementException.class).ignoring(StaleElementReferenceException.class); elementToBeClicked.click();
}
Vous pouvez explicitement attendre qu'un élément apparaisse sur la page Web avant de pouvoir entreprendre une action (comme element.click ()).
driver.get("http://somedomain/url_that_delays_loading");
WebElement myDynamicElement = (new WebDriverWait(driver, 10))
.until(new ExpectedCondition<WebElement>(){
@Override
public WebElement apply(WebDriver d) {
return d.findElement(By.id("myDynamicElement"));
}});
C'est ce que j'ai utilisé pour un scénario similaire et cela fonctionne bien.
Vous pouvez utiliser cet extrait de code pour charger la page:
IWait wait = new OpenQA.Selenium.Support.UI.WebDriverWait(driver,TimeSpan.FromSeconds(30.00));
wait.Until(driver1 => ((IJavaScriptExecutor)driver).ExecuteScript("return document.readyState").Equals("complete"));Ou vous pouvez utiliser le serveur pour que n'importe quel élément soit chargé et devienne visible/cliquable sur cette page, très probablement ce qui sera chargé à la fin du chargement, comme ceci:
Wait.Until(ExpectedConditions.ElementToBeClickable(By.XPath(xpathOfElement));
var element = GlobalDriver.FindElement(By.XPath(xpathOfElement));
var isSucceededed = element != null;Voici une version Java 8 de la réponse la plus votée :
WebDriverWait wait = new WebDriverWait(myDriver, 15);
wait.until(webDriver -> ((JavascriptExecutor) myDriver).executeScript("return document.readyState").toString().equals("complete"));
Où myDriver est un objet WebDriver (déclaré plus tôt).
Remarque : Sachez que cette méthode (document.readyState) ne vérifie que le DOM.
La meilleure façon que j'ai vue consiste à utiliser la stalenessOf ExpectedCondition, à attendre que l'ancienne page devienne obsolète.
Exemple:
WebDriver driver = new FirefoxDriver();
WebDriverWait wait = new WebDriverWait(driver, 10);
WebElement oldHtml = driver.findElement(By.tagName("html"));
wait.until(ExpectedConditions.stalenessOf(oldHtml));
Il faudra attendre dix secondes pour que l'ancienne balise HTML devienne obsolète, puis émettre une exception si cela ne se produit pas.
J'utilise noeud + sélénium-webdriver (dont la version est 3.5.0 maintenant). ce que je fais pour ça, c'est:
var webdriver = require('Selenium-webdriver'),
driver = new webdriver.Builder().forBrowser('chrome').build();
;
driver.wait(driver.executeScript("return document.readyState").then(state => {
return state === 'complete';
}))
Pour une attente implicite, vous pouvez utiliser quelque chose comme suit:
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS)
Pour que la page Web attende qu'un objet spécifique soit visible ou que la condition cerntain soit vraie. Vous pouvez utiliser la plume d'attente du pilote Web.
//120 is maximum number of seconds to wait.
WebDriverWait wait = new WebDriverWait(driver,120);
wait.until(ExpectedConditions.elementToBeClickable("CONDITITON"));
Dans Java, une autre option consiste à mettre le thread en veille à une heure précise.
Thread.sleep(numberOfSeconds*1000);
//This line will cause thread to sleep for seconds as variable
J'ai créé une méthode pour simplifier la méthode thread.sleep
public static void wait_time(int seconds){
try {
Thread.sleep(seconds*1000);
}catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Utilisez la méthode comme wait_time (10); Le fil va dormir pendant 10 secondes.
Comment faire en sorte que Selenium attend le chargement de la page après un clic fournit l'approche intéressante suivante:
- Stocker une référence à un
WebElementde l'ancienne page. - Cliquer sur le lien.
- Continuez à appeler des opérations sur la
WebElementjusqu'à ce queStaleElementReferenceExceptionsoit lancé.
Exemple de code:
WebElement link = ...;
link.click();
new WebDriverWait(webDriver, timeout).until((org.openqa.Selenium.WebDriver input) ->
{
try
{
link.isDisplayed();
return false;
}
catch (StaleElementReferenceException unused)
{
return true;
}
});
private static void checkPageIsReady(WebDriver driver) {
JavascriptExecutor js = (JavascriptExecutor) driver;
// Initially bellow given if condition will check ready state of page.
if (js.executeScript("return document.readyState").toString().equals("complete")) {
System.out.println("Page Is loaded.");
return;
}
// This loop will rotate for 25 times to check If page Is ready after
// every 1 second.
// You can replace your value with 25 If you wants to Increase or
// decrease wait time.
for (int i = 0; i < 25; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
// To check page ready state.
if (js.executeScript("return document.readyState").toString().equals("complete")) {
break;
}
}
}
public static int counter = 0;
public void stepGeneralWait() {
boolean breakIt = true;
while (true) {
breakIt = true;
try {
do{
// here put e.g. your spinner ID
Controller.driver.findElement(By.xpath("//*[@id='static']/div[8]/img")).click();
Thread.sleep(10000);
counter++;
if (counter > 3){
breakIt = false;
}
}
while (breakIt);
} catch (Exception e) {
if (e.getMessage().contains("element is not attached")) {
breakIt = false;
}
}
if (breakIt) {
break;
}
}
try {
Thread.sleep(12000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Vous pouvez essayer ce code pour laisser la page se charger complètement jusqu'à ce que l'élément soit trouvé.
public void waitForBrowserToLoadCompletely() {
String state = null;
String oldstate = null;
try {
System.out.print("Waiting for browser loading to complete");
int i = 0;
while (i < 5) {
Thread.sleep(1000);
state = ((JavascriptExecutor) driver).executeScript("return document.readyState;").toString();
System.out.print("." + Character.toUpperCase(state.charAt(0)) + ".");
if (state.equals("interactive") || state.equals("loading"))
break;
/*
* If browser in 'complete' state since last X seconds. Return.
*/
if (i == 1 && state.equals("complete")) {
System.out.println();
return;
}
i++;
}
i = 0;
oldstate = null;
Thread.sleep(2000);
/*
* Now wait for state to become complete
*/
while (true) {
state = ((JavascriptExecutor) driver).executeScript("return document.readyState;").toString();
System.out.print("." + state.charAt(0) + ".");
if (state.equals("complete"))
break;
if (state.equals(oldstate))
i++;
else
i = 0;
/*
* If browser state is same (loading/interactive) since last 60
* secs. Refresh the page.
*/
if (i == 15 && state.equals("loading")) {
System.out.println("\nBrowser in " + state + " state since last 60 secs. So refreshing browser.");
driver.navigate().refresh();
System.out.print("Waiting for browser loading to complete");
i = 0;
} else if (i == 6 && state.equals("interactive")) {
System.out.println(
"\nBrowser in " + state + " state since last 30 secs. So starting with execution.");
return;
}
Thread.sleep(4000);
oldstate = state;
}
System.out.println();
} catch (InterruptedException ie) {
ie.printStackTrace();
}
}
La solution la plus simple consiste simplement à attendre un élément qui apparaîtra sur la page chargée.
Si vous souhaitez cliquer sur un bouton déjà après le chargement de la page, vous pouvez utiliser wait et cliquer sur:
await().until().at.most(20, TimeUnit.Seconds).some_element.isDisplayed(); // or another condition
getDriver().find(some_element).click;
utiliser le code suivant, il est très facile et simple pour le chargement de page.
public void PageLoad(IWebDriver driver, By by)
{
try
{
Console.WriteLine("PageLoad" + by);
WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(30));
wait.Until(ExpectedConditions.ElementIsVisible(by));
wait = new WebDriverWait(driver, TimeSpan.FromSeconds(30)); // 30 seconds wait until element not found.
wait.Until(ExpectedConditions.ElementToBeClickable(by));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Assert.Fail("Element not found!")
}
}
j'espère que ceci vous aide.
WebDriver driver = new ff / chrome / anyDriverYouWish(); driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);Attend 10 secondes maximum.WebDriverWait wait = new WebDriverWait(driver, 10); wait.until(ExpectedConditions.visibilityOf(WebElement element));FluentWait<Driver> fluentWait; fluentWait = new FluentWait<>(driver).withTimeout(30, TimeUnit.SECONDS) .pollingEvery(200, TimeUnit.MILLISECONDS) .ignoring(NoSuchElementException.class);
L'avantage de la dernière option est que vous pouvez inclure une exception à laquelle vous pouvez vous attendre afin que votre exécution se poursuive.
driver.asserts().assertElementFound("Page was not loaded",
By.xpath("//div[@id='actionsContainer']"),Constants.LOOKUP_TIMEOUT);
utiliser une condition if et pour tout élément présent
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}