Selenium Aspetta – Implicito ed Esplicito con Sintassi
Krishna rungta
In Selenium, le “attese” svolgono un ruolo importante nell'esecuzione dei test. In questo tutorial imparerai vari aspetti e la differenza tra l'attesa implicita ed esplicita Selenium.
Perché abbiamo bisogno di attese Selenium?
La maggior parte delle applicazioni web vengono sviluppate utilizzando Ajax e Javascript. Quando una pagina viene caricata dal browser, gli elementi con cui vogliamo interagire possono caricarsi a intervalli di tempo diversi.
Non solo rende difficile identificare l'elemento, ma anche se l'elemento non viene localizzato verrà generato un messaggio "ElementNotVisibleException" eccezione. Utilizzando Selenium Aspetta, possiamo risolvere questo problema.
Consideriamo uno scenario in cui dobbiamo utilizzare sia le attese implicite che quelle esplicite nel nostro test. Si supponga che il tempo di attesa implicito sia impostato su 20 secondi e che il tempo di attesa esplicito sia impostato su 10 secondi.
Supponiamo di cercare di trovare un elemento che ne abbia alcuni “Condizioni attese "(Attesa esplicita), se l'elemento non si trova entro l'intervallo di tempo definito dall'attesa esplicita (10 secondi), utilizzerà l'intervallo di tempo definito dall'attesa implicita (20 secondi) prima di generare un "ElementNotVisibleException".
Selenium Il driver Web attende
- Attesa implicita
- Aspetta esplicita
In questo tutorial imparerai i diversi tipi di attesa Selenium:
Attesa implicita Selenium
Attesa implicita Selenium viene utilizzato per dire al driver web di attendere un certo periodo di tempo prima di generare un'eccezione "No Such Element Exception". L'impostazione predefinita è 0. Una volta impostato il tempo, il driver web attenderà l'elemento per quel periodo di tempo prima di generare un'eccezione.
Selenium Web Driver ha preso in prestito l'idea delle attese implicite da Watir.
Nell'esempio seguente abbiamo dichiarato un'attesa implicita con un intervallo di tempo di 10 secondi. Ciò significa che se l'elemento non si trova sulla pagina web entro tale intervallo di tempo, genererà un'eccezione.
Per dichiarare l'attesa implicita Selenium Driver Web:
Sintassi di attesa implicita:
driver.manage().timeouts().implicitlyWait(TimeOut, TimeUnit.SECONDS);
package guru.test99;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.Test;
public class AppTest {
protected WebDriver driver;
@Test
public void guru99tutorials() throws InterruptedException
{
System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
driver = new ChromeDriver();
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
String eTitle = "Demo Guru99 Page";
String aTitle = "" ;
// launch Chrome and redirect it to the Base URL
driver.get("https://demo.guru99.com/test/guru99home/" );
//Maximizes the browser window
driver.manage().window().maximize() ;
//get the actual value of the title
aTitle = driver.getTitle();
//compare the actual title with the expected title
if (aTitle.equals(eTitle))
{
System.out.println( "Test Passed") ;
}
else {
System.out.println( "Test Failed" );
}
//close browser
driver.close();
}
}
Spiegazione del codice
Nell'esempio sopra,
Considerare il seguente codice:
driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
L'attesa implicita accetterà 2 parametri, il primo parametro accetterà il tempo come valore intero e il secondo parametro accetterà la misurazione del tempo in termini di SECONDI, MINUTI, MILISECONDI, MICROSECONDI, NANOSECONDI, GIORNI, ORE, ecc.
Aspetta esplicita Selenium
Aspetta esplicita Selenium viene utilizzato per dire al Web Driver di attendere determinate condizioni (Expected Conditions) o il tempo massimo superato prima di generare l'eccezione "ElementNotVisibleException". È un tipo intelligente di attesa, ma può essere applicato solo per elementi specificati. Offre opzioni migliori rispetto all'attesa implicita poiché attende gli elementi Ajax caricati dinamicamente.
Una volta dichiarata l'attesa esplicita dobbiamo utilizzare “Condizioni previste” oppure possiamo configurare la frequenza con cui vogliamo controllare la condizione utilizzando Aspetta fluente. In questi giorni durante l'implementazione stiamo utilizzando Discussione.Sonno() generalmente se ne sconsiglia l'uso
Nell'esempio seguente, stiamo creando l'attesa di riferimento per "WebDriverAttendi" e istanziare utilizzando "webdriver" riferimento, e stiamo dando un intervallo di tempo massimo di 20 secondi.
Sintassi di attesa esplicita:
WebDriverWait wait = new WebDriverWait(WebDriverRefrence,TimeOut);
package guru.test99;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.annotations.Test;
public class AppTest2 {
protected WebDriver driver;
@Test
public void guru99tutorials() throws InterruptedException
{
System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
driver = new ChromeDriver();
WebDriverWait wait=new WebDriverWait(driver, 20);
String eTitle = "Demo Guru99 Page";
String aTitle = "" ;
// launch Chrome and redirect it to the Base URL
driver.get("https://demo.guru99.com/test/guru99home/" );
//Maximizes the browser window
driver.manage().window().maximize() ;
//get the actual value of the title
aTitle = driver.getTitle();
//compare the actual title with the expected title
if (aTitle.contentEquals(eTitle))
{
System.out.println( "Test Passed") ;
}
else {
System.out.println( "Test Failed" );
}
WebElement guru99seleniumlink;
guru99seleniumlink= wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath( "/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i")));
guru99seleniumlink.click();
}
}
Spiegazione del codice
Considerare il seguente codice:
WebElement guru99seleniumlink;
guru99seleniumlink = wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i")));
guru99seleniumlink.click();
In questo esempio di attesa di WebDriver, attendere il periodo di tempo definito nella sezione "WebDriverAttendi" classe o il "Condizioni previste" che si verifichi a seconda di quale evento si verifica per primo.
Quanto sopra Java codice afferma che stiamo aspettando un elemento per l'intervallo di tempo di 20 secondi come definito nel "WebDriverAttendi" sulla pagina web finché non viene visualizzato il messaggio "Condizioni previste" sono soddisfatte e la condizione è "visibilitàdell'ElementoLocato".
Di seguito sono riportate le condizioni previste che possono essere utilizzate in Selenium Aspetta esplicita
- alertIsPresent()
- elementoSelectionStateToBe()
- elementoToBeClickable()
- elementoToBeSelected()
- frameToBeAvaliableAndSwitchToIt()
- invisibilitàOfTheElementLocated()
- invisibilityOfElementWithText()
- presenzaOfAllElementsLocatedBy()
- presenzaOfElementLocated()
- textToBePresentInElement()
- textToBePresentInElementLocated()
- textToBePresentInElementValue()
- titoloIs()
- titoloContiene()
- visibilitàDi()
- visibilitàOfAllElements()
- visibilitàOfAllElementsLocatedBy()
- visibilitàOfElementLocated()
Ottima attesa Selenium
Ottima attesa Selenium viene utilizzato per definire il tempo massimo di attesa di una condizione da parte del driver Web, nonché la frequenza con cui vogliamo controllare la condizione prima di generare un'eccezione "ElementNotVisibleException". Controlla l'elemento Web a intervalli regolari finché l'oggetto non viene trovato o si verifica un timeout.
Frequenza: Impostazione di un ciclo di ripetizione con l'intervallo di tempo per verificare/controllare la condizione a intervalli di tempo regolari
Consideriamo uno scenario in cui un elemento viene caricato a intervalli di tempo diversi. L'elemento potrebbe caricarsi entro 10 secondi, 20 secondi o anche di più se dichiariamo un'attesa esplicita di 20 secondi. Attenderà fino al tempo specificato prima di generare un'eccezione. In tali scenari, l'attesa fluente è l'attesa ideale da utilizzare poiché proverà a trovare l'elemento a frequenze diverse finché non lo trova o finché non scade il timer finale.
Sintassi di attesa fluida:
Wait wait = new FluentWait(WebDriver reference) .withTimeout(timeout, SECONDS) .pollingEvery(timeout, SECONDS) .ignoring(Exception.class);
Il codice precedente è deprecato in Selenium v3.11 e successive. Devi usare
Wait wait = new FluentWait(WebDriver reference) .withTimeout(Duration.ofSeconds(SECONDS)) .pollingEvery(Duration.ofSeconds(SECONDS)) .ignoring(Exception.class);
package guru.test99;
import org.testng.annotations.Test;
import java.util.NoSuchElementException;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.support.ui.Wait;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.annotations.Test;
public class AppTest3 {
protected WebDriver driver;
@Test
public void guru99tutorials() throws InterruptedException
{
System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
String eTitle = "Demo Guru99 Page";
String aTitle = "" ;
driver = new ChromeDriver();
// launch Chrome and redirect it to the Base URL
driver.get("https://demo.guru99.com/test/guru99home/" );
//Maximizes the browser window
driver.manage().window().maximize() ;
//get the actual value of the title
aTitle = driver.getTitle();
//compare the actual title with the expected title
if (aTitle.contentEquals(eTitle))
{
System.out.println( "Test Passed") ;
}
else {
System.out.println( "Test Failed" );
}
Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)
.withTimeout(30, TimeUnit.SECONDS)
.pollingEvery(5, TimeUnit.SECONDS)
.ignoring(NoSuchElementException.class);
WebElement clickseleniumlink = wait.until(new Function<WebDriver, WebElement>(){
public WebElement apply(WebDriver driver ) {
return driver.findElement(By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i"));
}
});
//click on the selenium link
clickseleniumlink.click();
//close~ browser
driver.close() ;
}
}
Spiegazione del codice
Considerare il seguente codice:
Wait<WebDriver> wait = new FluentWait<WebDriver>(driver) .withTimeout(30, TimeUnit.SECONDS) .pollingEvery(5, TimeUnit.SECONDS) .ignoring(NoSuchElementException.class);
Nell'esempio sopra, stiamo dichiarando un'attesa fluente con un timeout di 30 secondi e la frequenza è impostata su 5 secondi ignorando "NoSuchElementException"
Considerare il seguente codice:
public WebElement apply(WebDriver driver) {
return driver.findElement(By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i"));
Abbiamo creato una nuova funzione per identificare l'elemento Web sulla pagina. (Es: qui Web Element non è altro che il file Selenium collegamento nella pagina web).
La frequenza è impostata su 5 secondi e il tempo massimo è impostato su 30 secondi. Ciò significa che controllerà l'elemento sulla pagina web ogni 5 secondi per un tempo massimo di 30 secondi. Se l'elemento si trova entro questo intervallo di tempo eseguirà le operazioni altrimenti lancerà un "ElementNotVisibleException"
Controlla anche: - Selenium Tutorial IDE per principianti
Differenza tra attesa implicita e attesa esplicita
Di seguito è riportata la differenza principale tra attesa implicita e attesa esplicita in Selenium:
| Attesa implicita | Aspetta esplicita |
|---|---|
| Il tempo di attesa implicito viene applicato a tutti gli elementi nello script | Il tempo di attesa esplicito viene applicato solo a quegli elementi da noi previsti |
| Nell'attesa implicita, abbiamo bisogno non è un specificare "Condizioni previste" sull'elemento da individuare | In Explicit Wait, dobbiamo specificare "ExpectedConditions" sull'elemento da individuare |
| Si consiglia di utilizzare quando gli elementi si trovano nell'intervallo di tempo specificato in Selenium attesa implicita | Se ne consiglia l'utilizzo quando il caricamento degli elementi impiega molto tempo e anche per verificare la proprietà dell'elemento like(visibilityOfElementLocated, elementToBeClickable,elementToBeSelected) |
Conclusione
L'attesa implicita, esplicita e fluente sono le diverse attese utilizzate Selenium. L'utilizzo di queste attese dipende totalmente dagli elementi che vengono caricati a diversi intervalli di tempo. Non è sempre consigliabile utilizzare Thread.Sleep() while Testing la nostra applicazione o costruendo il nostro framework.
Controlla anche: - Selenium Tutorial per principianti: impara WebDriver in 7 giorni
