Importanti comandi webdriver Selenium del 2021

by

In questa serie di tutorial impareremo a conoscere tutti i comandi webdriver selenio esaurienti a partire dai comandi selenio molto basilari ai comandi webdriver Selenium avanzati nell'ordine di articoli seguente: 

Comandi di base del driver Web Selenium -Domande: 

Selenio intermedio driver web comandi -Domande:

Comandi avanzati Selenium WebDriver -Domande:

Comandi di base del selenio - Risposte: 

comandi webdriver selenio
Comandi webdriver selenio

Selenio vai all'URL:

In Selenium Webdriver se vogliamo navigare o aprire qualsiasi URL specifico tramite il nostro browser, possiamo farlo principalmente con due approcci diversi uno con il metodo get () e un altro con navigate, daremo un'occhiata a come potrebbe essere fatto : 

public void getUrl(String url) { try { driver.get(url); BASE_LOGGER.info("Navigato con successo all'URL come: " + url); } catch (Eccezione ex) { Stringa exceptionData = ex.getCause().getMessage(); BASE_LOGGER.error("Impossibile navigare all'URL: " + url + " con l'errore come: " +exceptionData); } }

Il codice che puoi scrivere per navigare nell'URL è driver.get ("http://example.com") mentre il driver è l'istanza Webdriver dell'interfaccia Selenium WebDriver.

visita qui per capire come avviare tutti i browser in Selenium.

Come funziona il metodo get internamente in Selenium: 

Una volta che questo metodo get () viene chiamato dallo script di test, il riferimento Webdriver cioè il driver aspetterà fino a quando la pagina viene caricata, in realtà il metodo get () si attiva internamente funzione onload che restituisce l'handle al riferimento del driver una volta che la pagina è completamente caricata.

Selenio vai avanti e torna indietro:

Un altro approccio per navigare all'URL con la cronologia del browser è utilizzare il metodo navigate (), in cui Selenium utilizza la cronologia del browser per navigare in avanti o tornare indietro con i rispettivi URL come: 

Il selenio va avanti

public void navigateForward() { try { driver.navigate().forward(); BASE_LOGGER.info("Navigazione in avanti con successo"); } catch (Eccezione ex) { Stringa exceptionData = ex.getCause().getMessage(); BASE_LOGGER.error("Impossibile navigare con l'errore come: " +exceptionData); } }

Selenio torna indietro: 

public void navigateBack() { try { driver.navigate().back(); BASE_LOGGER.info("Ritorno all'URL navigato con successo "); } catch (Eccezione ex) { Stringa exceptionData = ex.getCause().getMessage(); BASE_LOGGER.error("Impossibile tornare all'URL: con l'errore come: " +exceptionData); } } 

Pagina di aggiornamento del selenio

Possiamo usare il metodo refresh () da Selenium navigate 

public void seleniumRefreshPage() { prova { driver.navigate().refresh(); BASE_LOGGER.info("Pagina di aggiornamento del selenio completata con successo"); } catch (Eccezione ex) { Stringa exceptionData = ex.getCause().getMessage(); BASE_LOGGER.error("Impossibile eseguire l'aggiornamento della pagina di Selenium: con l'errore come: " +exceptionData); } }

Clic selenio

Per eseguire qualsiasi operazione di clic con Selenium click dobbiamo utilizzare il metodo chiamato click () nell'approccio sottostante, ci sono altri modi per eseguire l'operazione di clic su qualsiasi WebElement in Selenium, ad esempio utilizzando JavaScriptClick che è molto utile a volte a seconda delle situazioni dove il tuo normale metodo di clic selenio funziona in modo molto stabile, ci sono alcuni casi in cui se stai automatizzando con il browser IE e se l'applicazione Web sotto test è costruita in una sorta di JS bootstrap, il normale metodo di clic selenio potrebbe non funzionare a volte , in questi casi potresti utilizzare il metodo di clic Javascript.

public void safeClick(Per elemento) { try { driver.findElement(elemento).click(); BASE_LOGGER.info("L'operazione Safeclick è stata eseguita per il localizzatore: " + String.valueOf(elemento)); } catch (Eccezione e) { Stringa exceptionData = e.getCause().getMessage(); BASE_LOGGER.error("Errore riscontrato ie : " +exceptionData + " durante l'esecuzione di Safeclick sull'elemento: " + element); } }

È possibile passare l'elemento utilizzando diverse strategie di localizzazione (ad esempio xpath, name, css, ecc.) Nel metodo chiamato findElement () e quindi eseguire l'operazione del metodo click () come sopra.

Chiavi di selenio

Quando abbiamo bisogno di inserire del testo in qualche casella di testo tramite Selenium, utilizziamo il metodo Selenium sendkeys () passando il "Testo da inserire" come parametro nel metodo sendKeys ("Testo da inserire") e simile a il metodo click () questo metodo viene applicato anche a qualsiasi webElement (qui casella di testo web) quindi dobbiamo usare driver.findElement per inviare il testo a quel TextBox.

Il codice di esempio funziona così: 

public void enterTextIntoElement(Per elemento, String textToBeEntered) { try { driver.findElement(element).sendKeys(textToBeEntered); BASE_LOGGER.info( "l'operazione enterTextIntoElement è stata eseguita per il locator: " + String.valueOf(elemento)); } catch (Eccezione ex) { Stringa exceptionData = ex.getCause().getMessage(); BASE_LOGGER.error("l'operazione enterTextIntoElement non è riuscita per il locator : " + String.valueOf(element) + " con l'eccezione ie : " + exceptionData); } }

Campo di testo trasparente al selenio

Se vogliamo cancellare qualsiasi dato da un campo di testo precedentemente riempito, possiamo usare il metodo chiamato clear () e anche con l'aiuto di Keys Class in Selenium possiamo farlo, attraverso il quale possiamo prendere direttamente le operazioni da tastiera insieme alle scorciatoie da tastiera :

Per cancellare i dati con l'aiuto del metodo clear () possiamo scrivere nell'approccio seguente: 

public void clearField(Per elemento) { try { driver.findElement(elemento).clear(); BASE_LOGGER.info("L'operazione ClearField è stata eseguita per il locator: " + String.valueOf(elemento)); } catch (Eccezione e) { Stringa exceptionData = e.getCause().getMessage(); BASE_LOGGER.error("L'operazione ClearField non è riuscita per il locator: " + String.valueOf(elemento) + " con l'eccezione ie: " +exceptionData); } }

Usando la classe Keys possiamo anche cancellare i campi di testo nel seguente approccio.

Finestra di ingrandimento del selenio

Mentre lavoriamo con l'automazione del browser, se dobbiamo massimizzare la finestra in Selenium, potremmo usare i seguenti approcci: 

Selenium Maximize Window utilizzando il metodo Maximize ():  

public void massimizzareWindow() { try { driver.manage().window().maximize(); BASE_LOGGER.info("Finestra ingrandita con successo"); } catch (Eccezione e) { BASE_LOGGER.info("Si è verificata un'eccezione durante l'ingrandimento della finestra come: " + e.getCause().getMessage()); } }

Selenium Maximize Window utilizzando ChromeOptions per ChromeBrowser:

Utilizzando il metodo seguente, stiamo impostando un'istanza del browser Chrome per Webdriver in modalità ingrandita e la sessione del driver restituita continuerà con la stessa funzionalità (ad esempio, massimizza la finestra) per ulteriori operazioni web come da script.

public WebDriver openBrowserInMaximizeWindow(){ prova {Opzioni ChromeOptions = new ChromeOptions(); options.addArguments("start-massimizzato"); Driver WebDriver = nuovo ChromeDriver(opzioni); }catch(Eccezione e){ BASE_LOGGER.error("Eccezione riscontrata con : " + e.getCause().getMessage()); } ritorno autista; }

Finestra di minimizzazione del selenio

Possiamo ridurre a icona la finestra utilizzando il comando Selenium reduce () con il seguente approccio:  

public void reduceWindow() { try { driver.manage().window().minimize(); BASE_LOGGER.info("Finestra ridotta a icona"); } catch (Eccezione e) { BASE_LOGGER.info("Si è verificata un'eccezione durante la riduzione a icona della finestra come: " + e.getCause().getMessage()); } }

Selenio chiudere il browser:

Per chiudere il browser in Selenium usiamo il metodo close () nell'approccio seguente: 

public void closeCurrentWindow() { try { if (null != driver) { driver.close(); BASE_LOGGER.info("Chiuso con successo la Finestra/Browser corrente"); } else { BASE_LOGGER.info("Impossibile chiudere l'istanza corrente di Window/browser come NULL"); } } catch (Eccezione e) { BASE_LOGGER.info("Si è verificata un'eccezione durante la chiusura della finestra/browser corrente"); } }

Selenium chiudi il browser

Per chiudere tutte le istanze del browser in Selenium usiamo il metodo quit () nell'approccio seguente: 

public void quitBrowser() { try { if (null != driver) { driver.quit(); BASE_LOGGER.info("Chiudi con successo il browser"); } else { BASE_LOGGER.info("Impossibile USCIRE dal browser come NULL"); } } catch (Eccezione e) { BASE_LOGGER.error("Si è verificata un'eccezione durante l'abbandono del browser"); } }

Differenza tra driver.close () e driver.quit () in selenio:

Comandi webdriver selenio intermedio - Risposte:

Menu a discesa in selenio:

Nella struttura DOM della pagina Web, il menu a discesa viene implementato selezionando o immettendo Tage of HTML .Per lavorare con Dropdown con Selenium ed eseguire determinati 

operazioni web nei menu a discesa, dobbiamo utilizzare la classe "Select" dall'API Selenium WebDrivers come parte di "org.openqa.selenium.support.ui"Pacchetto di Selenium WebDriver. 

Ci sono 2 diverse dichiarazioni di problemi o domande mentre si lavora con la selezione di DropDown in Selenium: 

Selezione di un singolo elemento alla volta in un menu a discesa

Nell'approccio seguente possiamo lavorare con Dropdown:  

Primo passo :

È necessario creare un handle per DropDown WebElement utilizzando la creazione di oggetti di classe Select nel modo seguente:

Seleziona seleziona = nuovo Seleziona (WebElement webelement);

Passo due : 

Esistono 3 diversi approcci per selezionare il valore dal menu a discesa in Selenium, potremmo utilizzare uno dei metodi seguenti per selezionare il valore dal menu a discesa in Selenium: 

Di seguito è riportato l'approccio che possiamo adottare per selezionare il valore dal menu a discesa: 

Menu a discesa in selenio - Approccio uno: 
In Approach One puoi usare il testo visibile della selezione desiderata del Webelement.

public void selectFromDropDownByText(By locator, String visibleText) { try { Select dropDownElement = new Select(driver.findElement(locator)); dropDownElement.selectByVisibleText(visibleText); BASE_LOGGER.info("L'operazione SelectFromDropDownByText è stata eseguita per il locator: " + String.valueOf(locator)); } catch (Eccezione e) { Stringa exceptionData = e.getCause().getMessage(); BASE_LOGGER.error("Errore riscontrato ie : " +exceptionData + " durante l'esecuzione di selectFromDropDownByText sull'elemento: " + locator); } }

Nel metodo sopra puoi passare il localizzatore del menu a discesa e il testo visibile che desideri selezionare dal menu a discesa, quindi eseguirà l'operazione desiderata selezionando l'elemento a discesa previsto. 

Menu a discesa in selenio - Approccio due:

In questo approccio si seleziona Webelement utilizzando l'attributo value della selezione WebElement desiderata dal menu a discesa: 

public void selectFromDropDownByValue(By locator, String visibleText) { try { Select dropDownElement = new Select(driver.findElement(locator)); dropDownElement.selectByValue ("Valore dell'elemento Web desiderato "); BASE_LOGGER.info("l'operazione selectFromDropDownByValue è stata eseguita per il locator: " + String.valueOf(locator)); } catch (Eccezione e) { Stringa exceptionData = e.getCause().getMessage(); BASE_LOGGER.error("Errore riscontrato ie : " +exceptionData + " durante l'esecuzione di selectFromDropDownByValue sull'elemento: " + locator); } }

Nel metodo sopra è possibile passare il localizzatore del menu a discesa e l'attributo del valore del WebElement di cui si desidera selezionare dal menu a discesa, quindi eseguirà l'operazione desiderata selezionando l'elemento a discesa previsto. 

Menu a discesa in selenio - Approccio tre:

In questo approccio si seleziona Webelement utilizzando l'indice (ordine del WebElement nel tag di selezione HTML) della selezione del WebElement desiderato dal menu a discesa, l'indice generalmente inizia da 0:

public void selectFromDropDownByIndex(By locator, String visibleText) { try { Select dropDownElement = new Select(driver.findElement(locator)); dropDownElement.selectByIndex(5); BASE_LOGGER.info("l'operazione selectFromDropDownByIndex è stata eseguita per il locator: " + String.valueOf(locator)); } catch (Eccezione e) { Stringa exceptionData = e.getCause().getMessage(); BASE_LOGGER.error("Errore riscontrato ie : " +exceptionData + " durante l'esecuzione di selectFromDropDownByIndex sull'elemento: " + locator); } }

Nel metodo sopra puoi passare il localizzatore del menu a discesa e l'indice / ordine del WebElement (nel Seleziona tag del menu a discesa) di cui vuoi selezionare dal menu a discesa, quindi eseguirà l'operazione desiderata selezionando l'elemento a discesa previsto .

Selezione di più elementi in un menu a discesa alla volta 

Dipende dalla struttura e dall'implementazione del DOM HTML se qualsiasi elemento a discesa può avere una selezione multipla di elementi. Per selezionare più elementi in Selenium dobbiamo seguire i due passaggi seguenti: 

Primo passo : Verificare se DropDown WebElement consente la selezione multipla utilizzando il metodo isMultiple (), questo restituisce booleano come vero o falso.

Passo due : se il passaggio precedente restituisce true, il menu a discesa consente la selezione multipla. Dopodiché possiamo utilizzare i tre approcci discussi sopra per selezionare più valori ed eseguire le operazioni desiderate ..

Quindi per concludere qui di seguito è il codice di esempio:

Elemento WebElement =driver.findElement(By.xpath("XPATH OF THE DropDown")); Seleziona selectMultiple = new Seleziona(elemento); if(selectMultiple.isMultiple()){ selectMultiple.selectByIndex(1); selectMultiple.selectByIndex(2); //Allo stesso modo potremmo usare altri approcci/metodi per selezionare elementi a discesa come selectByVisibleText o selectByValue }

Trascina e rilascia nel selenio :

Nel segmento del tutorial impareremo tutti i diversi approcci diversi di eseguire il Drag and Drop in Selenium come: 

Cos'è il drag and drop in Selenium e dove viene utilizzato: 

Trascina e rilascia è un'operazione specifica quando gli utenti navigano nelle tue applicazioni web e provano a eseguire un'operazione (trascinando con il movimento del mouse) su un elemento web che può muoversi liberamente sull'applicazione e può essere rilasciato in qualche altra posizione della pagina web di quell'applicazione. 

Qui l'elemento che viene trascinato è chiamato Source WebElement e l'elemento in cui viene rilasciato è chiamato Destination WebElement. 

Per eseguire gli scenari di cui sopra tramite l'automazione con Selenium, è necessario trascinare e rilasciare le funzionalità fornite da Selenium.

Diversi approcci di drag and drop in selenio:

Trascina e rilascia in Selenium usando il metodo Build (): 

Come funziona internamente il metodo Build () :

build () dalla classe Actions in Selenium che fa parte del pacchetto org.openqa.selenium.interactions genera internamente un'azione composita 

combinando tutte le azioni che sono state chiamate o attivate prima di chiamare il metodo build ().

Per un esempio:

new Actions(driver).clickAndHold(sourceElement).moveToElement(destinationElement) .release(destinationElement).build();

La dichiarazione precedente per eseguire la build dell'operazione di trascinamento della selezione viene utilizzata per associare le azioni precedenti come i metodi clickAndHold, moveToElement e release.

Ecco lo snippet di codice seguente per eseguire il Drag and Drop in Selenium utilizzando il metodo di compilazione della classe Actions: 

public void dragAndDrop(Per fonte, Per destinazione) { try { WebElement sourceElement = driver.findElement (source); Elemento di destinazione WebElement = driver.findElement(destinazione); Generatore di azioni = new Actions(driver); Azione dragAndDrop = builder.clickAndHold(sourceElement).moveToElement(destinationElement) .release(destinationElement).build(); dragAndDrop.perform(); BASE_LOGGER.info("Eseguita con successo l'azione Drag and Drop"); } catch (Eccezione e) { Stringa exceptionData = e.getCause().getMessage(); BASE_LOGGER.error("Errore riscontrato es: " +exceptionData + "durante l'esecuzione di DragAndDrop"); } }

Trascina e rilascia in Selenium usando il metodo dragAndDrop ():

Come funziona internamente il metodo dragAndDrop ():

Il metodo dragAndDrop (sourceWebElement, destinationWebElement) prende fondamentalmente due argomenti uno è l'origine e un altro è l'elemento web di destinazione. 
dragAndDrop elimina la necessità di clickAndHold, moveToElement, metodi di rilascio nella classe Action, gestisce internamente tutti gli scenari che vengono eseguiti da questi metodi.

Di seguito è riportato il frammento di codice seguente per eseguire dragAndDrop con il metodo dragAndDrop:

public void dragAndDropOps(Per fonte, Per destinazione) { try { WebElement sourceElement = driver.findElement (source); Elemento di destinazione WebElement = driver.findElement(destinazione); Generatore di azioni = new Actions(driver); builder.dragAndDrop(sourceElement,destinationElement).perform(); BASE_LOGGER.info("Eseguita con successo l'azione Drag and Drop"); } catch (Eccezione e) { Stringa exceptionData = e.getCause().getMessage(); BASE_LOGGER.error("Errore riscontrato es: " +exceptionData + "durante l'esecuzione di DragAndDrop"); } }

Trascina e rilascia in Selenium usando il metodo dragAndDropBy ():

Come funziona internamente il metodo dragAndDropBy (WebElement source, int xOffset, int yOffset):

Il metodo dragAndDropBy () accetta 3 argomenti che sono: 

Source WebElement: l'elemento che viene trascinato, ovvero l'elemento di origine 

xOffset: spostamento orizzontale dell'offset della posizione di destinazione 

yOffset: spostamento verticale dell'offset della posizione di destinazione 

Internamente questo metodo prende l'elemento web di origine e lo sposta e lo rilascia nella posizione di destinazione. Questo metodo è utile se desideri spostare qualsiasi elemento web di origine in qualsiasi posizione dei pixel.

Di seguito è riportato lo snippet di codice per DragAndDropBy in Selenium:

public void dragAndDropByOps(Per sorgente, int xOffSet, int yOffSet) { try { WebElement sourceElement = driver.findElement (source); Generatore di azioni = new Actions(driver); builder.dragAndDropBy(sourceElement,xOffSet,yOffSet).build().perform(); BASE_LOGGER.info("Eseguita con successo l'azione Drag and Drop"); } catch (Eccezione e) { Stringa exceptionData = e.getCause().getMessage(); BASE_LOGGER.error("Errore riscontrato es: " +exceptionData + "durante l'esecuzione di DragAndDrop"); } }

Visita qui per il resto dei set avanzati di comandi webdriver selenio intermedio.

Comandi avanzati Selenium WebDriver -Risposte:

Fare doppio clic in selenio :

Per replicare l'operazione, ovvero doppio clic in Selenium tramite mouse, dobbiamo eseguire il doppio clic tramite la classe Actions in Selenium e possiamo farlo nell'approccio seguente: 

public void doubleClick(By locator) { try { elemento WebElement = driver.findElement(locator); Actions actions = new Actions(driver); actions.doubleClick(elemento).perform(); BASE_LOGGER.info("Eseguito il doppio Click sull'Elemento: " + locator); } catch (StaleElementReferenceException e) { BASE_LOGGER.error("L'elemento non è allegato al documento della pagina " + e.getCause().getMessage()); } catch (NoSuchElementException e) { BASE_LOGGER.error("Element " + locator + " non è stato trovato in DOM " + e.getCause().getMessage()); } catch (Eccezione e) { BASE_LOGGER.error("Element " + locator + " non era selezionabile " + e.getCause().getMessage()); } }

Lo snippet di codice sopra è un metodo che fondamentalmente prende un argomento come Locator, ovvero il WebElement su cui deve essere eseguito il doppio clic.

Clic contestuale in selenio:

Per replicare l'operazione di clic contestuale o clic destro tramite il mouse, dobbiamo eseguire il metodo di clic contestuale tramite la classe Actions in Selenium e possiamo farlo con l'approccio seguente: 

public void rightClick (per localizzatore) { try { elemento WebElement = driver.findElement (localizzatore); Actions actions = new Actions(driver); actions.contextClick(elemento).perform(); BASE_LOGGER.info("Eseguito il contesto Clicca sull'Elemento: " + locator); } catch (StaleElementReferenceException e) { BASE_LOGGER.error("L'elemento non è allegato al documento della pagina " + e.getCause().getMessage()); } catch (NoSuchElementException e) { BASE_LOGGER.error("Element " + locator + " non è stato trovato in DOM " + e.getCause().getMessage()); } catch (Eccezione e) { BASE_LOGGER.error("Element " + locator + " non era selezionabile " + e.getCause().getMessage()); } }

Per i comandi dettagliati del webdriver Advance Selenium, visitare qui.. Anche per comprendere il Classe di azioni in selenio e le sue implementazioni visitate qui .

Domande frequenti critiche: 

Cos'è Manage () in Selenium?

driver.manage () restituisce un riferimento all'implementazione dell'interfaccia WebDriver.Options. L'interfaccia di opzioni è un'interfaccia per la gestione e la gestione delle azioni in un menu del browser come: 

Per serie esaustive di Domande per l'intervista al selenio - Visitate qui i set critici e avanzati.

Conclusione:

In questa sezione del tutorial abbiamo trattato il Basic Webdriver al selenio comandi, fare clic qui per apprendere i Comandi webdriver Selenium intermedio e avanzato. Per imparare il selenio da zero clicca qui.

     

Lascia un tuo commento