Verifica la presenza dell'elemento e attendi il comando in entrata Selenium

⚡ Riepilogo intelligente

Verifica la presenza dell'elemento e attendi i comandi in Selenium L'IDE verifica che una pagina contenga gli elementi e il testo previsti dal test e mette in pausa la riproduzione finché una condizione dinamica non diventa vera prima di eseguire il passaggio successivo.

🔘 Verifiche degli elementi: La funzione verifyElementPresent restituisce TRUE quando il localizzatore corrisponde a qualcosa sulla pagina, mentre verifyElementNotPresent è la sua esatta inversa.
☑️ Verifiche del testo: verifyTextPresent analizza l'intera pagina ed è sensibile alle maiuscole e minuscole, quindi "Atlanta" non corrisponde mai a "atlanta".
✅ Verifiche di posizionamento: Le funzioni verifyElementPositionLeft e verifyElementPositionTop confrontano lo spostamento in pixel di un elemento rispetto al bordo della pagina.
🧪 Caricamento della pagina: I comandi andWait, come clickAndWait, mettono in pausa lo script finché non è terminato il caricamento di una nuova pagina.
️ Contenuto dinamico: I comandi waitFor attendono il verificarsi di una condizione anziché il caricamento della pagina, il che è ideale per le schermate AJAX che non si ricaricano mai.
📊 IDE attuale: L'estensione del browser rinomina questi passaggi e assegna a ogni comando di attesa un proprio timeout in millisecondi.

Scopri di più

Un registrato Selenium IDE Lo script esegue clic e digita, ma da solo non decide mai se l'applicazione si è comportata correttamente. Due famiglie di comandi svolgono questo compito: verificare comandi, che controllano lo stato della pagina e aspettare comandi che sospendono l'esecuzione finché la pagina non è pronta per essere controllata.

⚠️ Nota sulle versioni: gli screenshot qui sotto provengono dall'originale Firefox-collegare Selenium IDE, che non viene più distribuito, e utilizzano i suoi nomi camelCase Selenese. L'IDE attuale è Chrome, Firefox e Bordo estensione del browserIl comportamento qui descritto è ancora valido, ma diversi nomi di comando sono cambiati: una mappaping La tabella compare più avanti in questo articolo e ogni comando e screenshot originali sono conservati esattamente come pubblicati.

Verifica la presenza di un elemento

Possiamo utilizzare i due comandi seguenti per verificare la presenza di un elemento:

verificareElementPresent – restituisce TRUE se l'elemento specificato è stato TROVATO nella pagina; FALSE in caso contrario
verificareElementNotPresent – restituisce VERO se l'elemento specificato NON è stato TROVATO in nessun punto della pagina; FALSO se è presente.

Entrambi i comandi prendono un elemento locator nella Target campo — un ID, un nome, un selettore CSS, un testo di collegamento o un XPath espressione — e nessuno dei due ha bisogno di un valore.

Lo script di test seguente verifica che la casella di testo UserName sia presente all'interno Mercury Homepage di Tours mentre la casella di testo Nome non lo è. La casella di testo Nome è in realtà un elemento presente nella pagina Registrazione di Mercury Tours, non nella home page.

Perché questi lo sono verificare comandi piuttosto che affermare Se si eseguono comandi, viene registrato un errore nel log e i passaggi rimanenti vengono comunque eseguiti. Questa distinzione è trattata in dettaglio più avanti.

Verifica la presenza di un determinato testo nel comando in Selenium

Verificare l'esistenza di un elemento non è sempre sufficiente: spesso un test deve confermare le parole mostrate all'utente. Due comandi di testo coprono questo caso.

verificareTextPresent – restituisce TRUE se la stringa di testo specificata è stata TROVATA da qualche parte nella pagina; FALSE in caso contrario
verificareTextNotPresent – restituisce VERO se la stringa di testo specificata NON è stata TROVATA in nessun punto della pagina; FALSO se è stato trovato

Ricorda che questi comandi fanno distinzione tra maiuscole e minuscole.

Il registro sottostante mostra la stessa pagina controllata due volte con due diverse ortografie della stessa frase.

Nello scenario sopra descritto, "Atlanta to Las Vegas" è stato trattato in modo diverso da "atlanta to Las Vegas" perché la lettera "A" di "Atlanta" era maiuscola nel primo caso, mentre nel secondo era minuscola. Quando il comando verifyTextPresent è stato applicato a entrambi, uno ha superato il controllo mentre l'altro ha fallito.

Verificare la posizione specifica di un elemento

I difetti di layout raramente compromettono un localizzatore, quindi i controlli di presenza non li rilevano. I comandi di posizione colmano questa lacuna.

Selenium L'IDE indica la posizione di un elemento misurando (in pixel) quanto dista dal bordo sinistro o superiore della finestra del browser.

verificareElementPositionLeft – verifica se il numero di pixel specificato corrisponde alla distanza dell'elemento dal bordo sinistro della pagina. Ciò restituirà FALSE se il valore specificato non corrisponde alla distanza dal bordo sinistro.
verificareElementPositionTop – verifica se il numero di pixel specificato corrisponde alla distanza dell'elemento dal bordo superiore della pagina. Ciò restituirà FALSE se il valore specificato non corrisponde alla distanza dal bordo superiore.

Lo script seguente registra gli offset dei pixel previsti nella colonna Valore.

Trattate questi due comandi con cautela. L'offset in pixel varia in base alle dimensioni della finestra, al livello di zoom e ai font installati, quindi un valore fisso che funziona su un computer potrebbe non funzionare su un altro.

Attendi i comandi Selenium

Un comando di verifica può controllare solo ciò che è già visualizzato sullo schermo, quindi un controllo eseguito troppo presto fallisce anche se l'applicazione è in esecuzione. I comandi di attesa risolvono questo problema di temporizzazione.

Di seguito sono riportati i tipi di comandi di attesa in Selenium

eAspetta comandi

Questi sono comandi che attenderanno il caricamento di una nuova pagina prima di passare al comando successivo.

Esempi sono

fare clic su E attendere
digitareAndAspettare
selezionaEAspetta

Ciascuno di essi è un normale comando di azione con il suffisso AndWait, come mostra il passaggio registrato qui sotto.

waitFor comandi

Si tratta di comandi che attendono che una condizione specificata diventi vera prima di procedere al comando successivo (indipendentemente dal caricamento di una nuova pagina). Questi comandi sono più appropriati per essere utilizzati su siti Web dinamici basati su AJAX che modificano valori ed elementi senza ricaricare l'intera pagina. Esempi inclusi:

waitForTitle
waitForTextPresent
waitForAlert

Considera lo scenario di Facebook di seguito.

Possiamo utilizzare una combinazione di “click” e “waitForTextPresent” per verificare la presenza del testo “Fornire il tuo compleanno”.

Non possiamo utilizzare clickAndWait perché nessuna pagina è stata caricata facendo clic su "Perché devo fornire la mia data di nascita?" collegamento. Se lo facciamo, il test fallirà

La stessa regola si applica a qualsiasi contenuto iniettato tramite script anziché tramite navigazione, motivo per cui Schermate basate su AJAX Nella maggior parte dei casi è necessario utilizzare waitFor anziché andWait.

Assert vs Verify vs waitFor Commands in Selenium IDE

I principianti spesso scelgono la famiglia sbagliata e poi si chiedono perché una suite si ferma al primo difetto, o perché segnala venti errori che tutti trace torniamo a uno. I tre prefissi rispondono a tre domande diverse.

Prefisso	Ciò che fa	In caso di fallimento	qui utilizzati per
affermare	Verifica immediatamente una condizione	Registra l'errore e interrompe il caso di test	Prerequisiti: un accesso che deve riuscire prima che qualsiasi altra cosa abbia senso.
verificare	Verifica immediatamente una condizione	Registra l'errore e continua con il comando successivo.	Verifiche indipendenti, come ad esempio diverse etichette su un'unica pagina di conferma
attendere	Sondaggi fino a quando la condizione non diventa vera	Registra l'errore una volta scaduto il timeout, quindi continua	Qualsiasi elemento che appare in ritardo: risposte AJAX, indicatori di caricamento, finestre di dialogo

Un modello pratico combina tutti e tre: verifica la pagina su cui sei atterrato, attendi l'elemento che arriva in modo asincrono, quindi verifica ogni singolo campo. Facendolo in quest'ordine, una navigazione interrotta interrompe il test in anticipo, mentre una manciata di discrepanze estetiche vengono segnalate in un'unica esecuzione. La stessa disciplina si applica a Selenium test scritti in codice, dove gli equivalenti sono asserzioni forti, asserzioni deboli e attese esplicite.

Verifica e attendi i comandi nel sistema corrente Selenium IDE

Migliori Firefox- Il plugin IDE che ha prodotto gli screenshot sopra è stato ritirato e il set di comandi è stato ricostruito per l'estensione del browser corrente. Diversi nomi Selenese sono sopravvissuti, alcuni sono stati rinominati e alcuni sono stati eliminati. La tabella seguente mappa i comandi utilizzati in questo articolo ai loro equivalenti attuali, tratti dalla documentazione ufficiale. Selenium Riferimento ai comandi IDE.

Comando Selenese Ereditario	Comando nell'IDE corrente
verificareElementPresent	verificare la presenza dell'elemento
verificareElementNotPresent	verificare l'elemento non presente
verificareTextPresent	verifica del testo (limitato a un localizzatore di elementi, non all'intera pagina)
verificareTextNotPresent	verifica non testo (con ambito a localizzatore di elementi)
verificaTitolo	verificare il titolo
verificaPosizioneElementoSinistra / verificaPosizioneElementoSuperiore	Nessun equivalente: le asserzioni di posizione sono state abbandonate
cliccaEattendi, digitaEattendi, selezionaEattendi	Nessun suffisso AndWait: il comando open attende già il caricamento della pagina.
waitForElementPresent	Attendi la presenza dell'elemento, con un tempo di attesa in millisecondi.
waitForAlert	Conferma l'avviso o verifica il testo dell'avviso dopo la visualizzazione della finestra di dialogo

Due differenze sono particolarmente importanti nel lavoro quotidiano. Innanzitutto, i comandi di attesa attuali (attendi la presenza dell'elemento, attendi la visibilità dell'elemento, attendi la modifica dell'elemento e le loro controparti negative) richiedono ciascuno un tempo di attesa esplicito in millisecondi, quindi un'operazione lenta non deve più condividere un unico timeout globale. In secondo luogo, la ricerca di testo a livello di pagina è stata eliminata: ora è presente il comando "verifica la necessità di un localizzatore per il testo", che di solito produce comunque un controllo più preciso.

Errori comuni con i comandi Verify e waitFor

La maggior parte dei problemi segnalati relativi a questi comandi non sono difetti dell'IDE. L'elenco seguente riporta gli errori più frequenti e le relative soluzioni.

L'elemento esiste, ma il controllo fallisce comunque. Presenza e visibilità sono stati diversi. Un elemento nascosto dietro una regola CSS è comunque presente nel DOM, quindi è opportuno abbinare il controllo di presenza all'attesa della visibilità dell'elemento quando il test dipende dal fatto che l'utente lo veda effettivamente.
Il controllo del testo fallisce se la formulazione appare identica. Gli spazi unificatori, gli spazi bianchi finali e gli apostrofi ricci copiati da un documento di progettazione non consentono una corrispondenza esatta. Riscrivi manualmente la stringa prevista anziché incollarla.
Un comando di attesa va in timeout su una pagina che è stata chiaramente caricata. L'elemento si trova solitamente all'interno di un iframe. Eseguire prima la selezione del frame, altrimenti il localizzatore verrà valutato rispetto al documento sbagliato.
clickAndWait si blocca su un'applicazione a pagina singola. Non avviene alcuna navigazione, quindi non c'è nulla da attendere. Sostituiscila con un clic seguito dal comando waitFor appropriato.
Il controllo della posizione ha esito positivo in locale, ma fallisce sul server di compilazione. Le dimensioni dello schermo e la resa dei caratteri variano. Si consiglia di preferire un controllo di presenza o di testo, oppure di impostare esplicitamente le dimensioni della finestra all'inizio del test.
L'intera suite si arresta alla prima discrepanza. È stato registrato un comando assert dove era previsto un comando verify. Invertendo il prefisso, l'esecuzione segnalerà ogni errore anziché solo il primo.

Una volta che uno script sopravvive a queste trappole, il passo successivo è solitamente quello di memorizzare i valori di runtime nelle variabili quindi i controlli vengono confrontati con dati reali anziché con stringhe predefinite.

DOMANDE FREQUENTI

L'IDE precedente condivideva un timeout globale per ogni passaggio waitFor, modificabile tramite il comando setTimeout. L'estensione attuale, invece, utilizza un tempo di attesa esplicito in millisecondi per ogni comando wait, in modo che una singola schermata lenta non costringa più tutti gli altri passaggi ad attendere per lo stesso tempo.

No. La funzione Pausa rimane sempre inattiva per tutta la durata, quindi spreca tempo quando la pagina è veloce e fallisce comunque quando è lenta. Utilizzala solo per dimostrare un passaggio durante una demo, mai in una suite che intendi eseguire ripetutamente.

No. La presenza significa che il nodo esiste nel DOM, e questo rimane vero anche per gli elementi nascosti tramite CSS o posizionati fuori dallo schermo. Quando il test dipende dalla visualizzazione di un elemento da parte dell'utente, aggiungi un'attesa della visibilità dell'elemento insieme al controllo di presenza.

Sì, e l'IDE attuale lo richiede. Il suo comando di verifica del testo accetta un localizzatore di elementi più la stringa prevista, che è più restrittiva della vecchia ricerca a livello di pagina e impedisce a una voce di menu non correlata di soddisfare un controllo che non era destinata a soddisfare.

Code La funzione export converte ogni comando in un'istruzione equivalente nella lingua di destinazione, in modo che un passaggio di attesa diventi un'attesa esplicita di WebDriver. Leggete il file generato prima di considerarlo attendibile, poiché i timeout e il comportamento di errore "soft" o "hard" non sempre vengono mantenuti intatti dopo la traduzione.

I modelli di machine learning leggono i dati storici di esecuzione e segnalano i passaggi che falliscono in modo intermittente anziché costante, il che è la caratteristica distintiva di un'attesa mancante. La riparazione del localizzatore assistita dall'IA affronta l'altra causa comune proponendo un nuovo selettore quando il markup cambia.

Gestisce bene la parte meccanica, trasformando un passaggio di attesa in un WebDriverWait con una condizione prevista. RevControlla il timeout che seleziona e la condizione che sceglie, poiché una condizione di presenza generata spesso deve essere una condizione di visibilità.

I localizzatori vengono valutati rispetto al documento attualmente selezionato, e un iframe è un elemento separato. Eseguire prima il comando di selezione del frame, poi il controllo e infine tornare al documento principale, in modo che i passaggi successivi non vengano eseguiti nel contesto errato.