Per il primo punto, è probabilmente una scelta personale. Non uso affatto lo implicit waiting
semplicemente perché mi piace avere il controllo su dove il selenio è in attesa e dove non lo è. L'impostazione del implicit wait
sta dicendo alla cieca Selenium, se non trovi il mio elemento, quindi aspetta un certo tempo finché non puoi. Non importa di cosa si tratta, indipendentemente dalle conseguenze, non importa quale pagina, si aspetta fino a quando non lo trovi o 20 secondi è passato.
Va bene se questo è il modo in cui si vuole andare, ma per me, il problema deriva dal fatto che se il mio elemento sta impiegando 30 secondi per apparire sulla pagina, allora questo è comunque un problema in sé. Il selenio lo nasconde, può coprire il problema.
Tuttavia, ci sono alcuni momenti l'elemento fa prendere un po 'di apparire e di essere 'pronto' e che quando viene in explicit waiting
. Quando si fa aspettano.
Per quanto riguarda l'attesa, ciò che accadrà inizialmente quando il tuo WebDriverWait
viene colpito, verrà eseguito e tenterà di trovare l'elemento. Il selenio vedrà che hai il tuo implicit wait
impostato in modo che proverà costantemente a trovare quell'elemento per un massimo di 20 secondi.
Lo farà "gratis", dietro le quinte.
Una volta che è scaduto, il vostro WebDriverWait
otterrà una risposta e dal momento che il vostro implicit wait
timeout è più grande del vostro WebDriverWait
timeout, cadrà sopra con un'eccezione (un'eccezione Timeout).
In termini di se il valore WebDriverWait
è superiore al valore implicit wait
(il vostro esempio nei commenti), allora il processo sarebbe:
- Eseguire il WebDriverWait inizialmente
- colpisce la chiamata
.FindElement
- Il selenio esegue questo, internamente, per 10 secondi
- Dopo i primi 10 secondi, il vostro
WebDriverWait
otterrebbe una risposta.
- Se l'elemento non viene trovato, viene eseguito nuovamente dal passaggio 1.
- Una volta raggiunto il passaggio 4, se l'elemento non viene trovato ancora, genererà un'eccezione di timeout.
Per spiegare ulteriormente (pseudo codice C#):
driver.Manage().Timeouts().SetImplicitWait(TimeSpan.FromSeconds(10));
WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(20));
wait.Until(w =>
{
return w.FindElement(By.Id("something")).Displayed;
}
Abbiamo un WebDriverWait
di 20 secondi, un implicit wait
di 10 secondi.
Colpirà:
return w.FindElement(By.Id("something")).Displayed;
per la prima volta. Il selenio, internamente, eseguirà il .FindElement
per 10 secondi. Dopo che sono passati 10 secondi, il mio WebDriverWait
verificherà le sue condizioni (.Displayed
). Se questo non è soddisfatto, allora il WebDriverWait
eseguirà di nuovo la stessa riga di codice. Anche in questo caso, il selenio farà come prima e funzionerà per 10 secondi. Una volta che torna da quello, se la condizione non è soddisfatta, significa che il tempo che lo WebDriverWait
ha atteso è di 20 secondi in totale e genera quindi un errore.
Si potrebbe desiderare di dare un'occhiata ai pensieri di JimEvans [qui] (http://stackoverflow.com/a/15174978/1177636). –
Ho dato un'occhiata a quella risposta ma risponde alla prima parte della mia domanda sopra. E la seconda parte? –
Questa risposta risponde anche alla seconda parte della tua domanda. La risposta (come affermato in quell'altro post) è "è un comportamento indefinito". – JimEvans