Selenio - Guida rapida
introduzione
Selenium è uno strumento di test del software automatizzato open source e portatile per testare le applicazioni web. Ha capacità di operare su diversi browser e sistemi operativi. Il selenio non è solo un singolo strumento, ma un insieme di strumenti che aiuta i tester ad automatizzare le applicazioni basate sul web in modo più efficiente.
Cerchiamo ora di capire ciascuno degli strumenti disponibili nella suite Selenium e il loro utilizzo.
Sr.No. | Strumento e descrizione |
---|---|
1 | Selenium IDE Selenio Iintegrato Dsviluppo Environment (IDE) è un plugin per Firefox che consente ai tester di registrare le loro azioni mentre seguono il flusso di lavoro di cui hanno bisogno per testare. |
2 | Selenium RC Selenio Remote Control (RC) era il framework di test di punta che consentiva più di semplici azioni del browser e un'esecuzione lineare. Utilizza tutta la potenza dei linguaggi di programmazione come Java, C #, PHP, Python, Ruby e PERL per creare test più complessi. |
3 | Selenium WebDriver Selenium WebDriver è il successore di Selenium RC che invia i comandi direttamente al browser e recupera i risultati. |
4 | Selenium Grid Selenium Grid è uno strumento utilizzato per eseguire test paralleli su macchine diverse e browser diversi contemporaneamente, il che si traduce in tempi di esecuzione ridotti al minimo. |
Vantaggi del selenio
QTP e Selenium sono gli strumenti più utilizzati nel mercato per i test di automazione del software. Quindi ha senso confrontare i pro di Selenium su QTP.
Selenio | QTP |
---|---|
Il selenio è uno strumento open source. | QTP è uno strumento commerciale e ciascuna delle licenze comporta un costo. |
Può essere esteso per varie tecnologie che espongono DOM. | Componenti aggiuntivi limitati e necessità di componenti aggiuntivi per ciascuna delle tecnologie. |
Ha la capacità di eseguire script su diversi browser. | Può eseguire test in versioni specifiche di Firefox, IE e Chrome. |
Può eseguire script su vari sistemi operativi. | Funziona solo con Windows. |
Supporta i dispositivi mobili. | Supporta i dispositivi mobili con l'aiuto di strumenti di terze parti. |
Esegue i test all'interno del browser, quindi lo stato attivo NON è richiesto mentre è in corso l'esecuzione dello script. | Richiede attenzione durante l'esecuzione dello script, poiché lo strumento agisce sul browser (imita le azioni dell'utente). |
Può eseguire test in parallelo con l'utilizzo di Selenium Grid. | QTP non può eseguire test in parallelo, tuttavia l'integrazione di QTP con QC consente ai tester di eseguire in parallelo. QC è anche uno strumento commerciale. |
Svantaggi del selenio
Parliamo ora delle insidie del selenio rispetto al QTP.
Selenio | QTP |
---|---|
Supporta solo applicazioni basate sul Web. | Può testare applicazioni web e desktop. |
Nessuna funzionalità come Object Repository / Recovery Scenario | QTP ha repository di oggetti incorporati e scenari di ripristino. |
Nessun IDE, quindi lo sviluppo dello script non sarà veloce come QTP. | IDE più intuitivo; l'automazione può essere ottenuta più velocemente. |
Impossibile accedere ai controlli all'interno del browser. | Può accedere ai controlli all'interno del browser come la barra dei preferiti, i pulsanti Indietro e Avanti. |
Nessuna generazione di report di prova predefinita. | Generazione del risultato del test predefinito all'interno dello strumento. |
Per la parametrizzazione, gli utenti devono fare affidamento sul linguaggio di programmazione. | La parametrizzazione è integrata e facile da implementare. |
Selenium-IDE (Integrated Development Environment) è un plug-in di Firefox facile da usare per sviluppare casi di test Selenium. Fornisce un'interfaccia utente grafica per registrare le azioni dell'utente utilizzando Firefox che viene utilizzata per apprendere e utilizzare Selenium, ma può essere utilizzata solo con il browser Firefox poiché altri browser non sono supportati.
Tuttavia, gli script registrati possono essere convertiti in vari linguaggi di programmazione supportati da Selenium e gli script possono essere eseguiti anche su altri browser.
La tabella seguente elenca le sezioni che tratteremo in questo capitolo.
Sr.No. | Descrizione del titolo |
---|---|
1 | Scarica Selenium IDE Questa sezione tratta di come scaricare e configurare Selenium IDE. |
2 | Caratteristiche IDE selenio Questa sezione tratta le funzionalità disponibili in Selenium IDE. |
3 | Creazione di test IDE di selenio Questa sezione tratta di come creare test IDE utilizzando la funzione di registrazione. |
4 | Debug degli script IDE al selenio Questa sezione si occupa del debug dello script IDE Selenium. |
5 | Inserimento di punti di verifica Questa sezione descrive come inserire punti di verifica in Selenium IDE. |
6 | Corrispondenza del modello di selenio Questa sezione tratta di come lavorare con le espressioni regolari usando IDE. |
7 | Estensioni utente selenio Lo script Java che consente agli utenti di personalizzare o aggiungere nuove funzionalità. |
8 | Diversa esecuzione del browser Questa sezione tratta di come eseguire gli script IDE Selenium su diversi browser. |
Per sviluppare gli script Selenium RC o WebDriver, gli utenti devono assicurarsi di aver eseguito la configurazione iniziale. La configurazione dell'ambiente prevede i seguenti passaggi.
- Scarica e installa Java
- Scarica e configura Eclipse
- Configura FireBug e FirePath
- Configura Selenium RC
- Configura Selenium WebDriver
Scarica e installa Java
Abbiamo bisogno di JDK (Java Development Kit) installato per poter lavorare con Selenium WebDriver / Selenium. Vediamo come scaricare e installare Java.
Step 1 - Vai all'UR.
https://www.oracle.com/technetwork/java/javase/downloads/index.html
Step 2 - Vai alla sezione "Download" e seleziona "Download JDK".
Step 3 - Seleziona il pulsante di opzione "Accetta contratto di licenza".
Step 4- Seleziona l'installazione appropriata. In questo caso, è il bit "Windows 7-64". Fare clic sul collegamento appropriato e salvare il file .exe sul disco.
Step 5- Esegui il file exe scaricato per avviare la procedura guidata di installazione. Fare clic su "Avanti" per continuare.
Step 6 - Seleziona le funzionalità e fai clic su "Avanti".
Step 7 - Il programma di installazione viene estratto e il suo avanzamento viene mostrato nella procedura guidata.
Step 8 - L'utente può scegliere il percorso di installazione e fare clic su "Avanti".
Step 9 - Il programma di installazione installa il JDK e i nuovi file vengono copiati.
Step 10 - Il programma di installazione si installa correttamente e mostra lo stesso all'utente.
Step 11- Per verificare se l'installazione è andata a buon fine, vai al prompt dei comandi e digita "java" come comando. L'output del comando è mostrato di seguito. Se l'installazione di Java non riesce o se NON è stata installata, verrà generato un errore di "comando sconosciuto".
Scarica e configura Eclipse
Step 1 - Vai all'URL: https://www.eclipse.org/downloads/ e scarica il file appropriato in base all'architettura del tuo sistema operativo.
Step 2 - Fare clic sul pulsante "Download".
Step 3- Il download sarebbe in un formato zippato. Decomprimere il contenuto.
Step 4 - Individua Eclipse.exe e fai doppio clic sul file.
Step 5 - Per configurare l'area di lavoro, selezionare la posizione in cui deve avvenire lo sviluppo.
Step 6 - La finestra Eclipse si apre come mostrato di seguito.
Configura FireBug e FirePath
Per lavorare con Selenium RC o WebDriver, dobbiamo individuare gli elementi in base al loro XPath, ID o nome, ecc. Per individuare un elemento, abbiamo bisogno di strumenti / plug-in.
Step 1 - Vai all'URL: https://addons.mozilla.org/en-US/firefox/addon/firebug/ e scarica il plugin.
Step 2 - Il programma di installazione del componente aggiuntivo viene mostrato all'utente e viene installato facendo clic sul pulsante "Installa".
Step 3 - Dopo l'installazione, possiamo avviare il plugin navigando su "Web Developer" >> "Firebug".
Step 4- FirePath, un plug-in che funziona all'interno di Firebug, aiuta gli utenti a catturare "XPath" di un elemento. Installa FirePath accedendo a "https://addons.mozilla.org/en-US/firefox/addon/firepath/"
Step 5 - Il programma di installazione del componente aggiuntivo viene mostrato all'utente e viene installato facendo clic sul pulsante "Installa".
Step 6 - Ora avvia "Firebug" navigando su "Strumenti" >> "Webdeveloper" >> "Firebug".
Esempio
Ora vediamo come utilizzare FireBug e FirePath con un esempio. A scopo dimostrativo, utilizzeremo www.google.com e acquisiremo le proprietà della casella di testo di "google.com".
Step 1- Per prima cosa fare clic sull'icona della freccia come evidenziato nello screenshot seguente e trascinarla sull'oggetto di cui vorremmo acquisire le proprietà. L'HTML / DOM dell'oggetto verrà visualizzato come mostrato di seguito. Siamo in grado di catturare l '"ID" della casella di testo di input con cui possiamo interagire.
Step 2 - Per recuperare l'XPath dell'oggetto, vai alla scheda "firepath" ed esegui i seguenti passaggi.
- Fare clic sull'icona Spia.
- Selezionare il controllo per il quale si desidera acquisire l'XPath.
- Viene generato XPath del controllo selezionato.
Configura Selenium RC
Vediamo ora come configurare il telecomando Selenium. Capiremo come sviluppare script con Selenium RC nei capitoli successivi, tuttavia per ora capiremo solo la parte relativa alla configurazione.
Step 1 - Vai alla sezione dei download di Selenium http://www.seleniumhq.org/download/ e scarica Selenium Server facendo clic sul suo numero di versione come mostrato di seguito.
Step 2- Dopo il download, dobbiamo avviare il Selenium Server. Per fare ciò, apri il prompt dei comandi e vai alla cartella in cui è conservato il file JAR scaricato come mostrato di seguito.
Step 3- Per avviare il server, utilizzare il comando 'java -jar << nome jar scaricato >> e se java JDK è installato correttamente, riceverai un messaggio di successo come mostrato di seguito. Ora possiamo iniziare a scrivere script Selenium RC.
Configura Selenium WebDriver
Ora vediamo come configurare Selenium WebDriver. Capiremo come sviluppare script con Selenium WebDriver nei capitoli successivi, tuttavia per ora ne capiremo solo la parte relativa alla configurazione.
Step 1 - Vai alla sezione dei download del selenio http://www.seleniumhq.org/download/ e scarica Selenium WebDriver facendo clic sul numero di versione come mostrato di seguito.
Step 2 - Il file scaricato è in formato zippato e bisogna decomprimere il contenuto per mapparlo alla cartella del progetto.
Step 3- Il contenuto decompresso verrà visualizzato come mostrato di seguito. Come mapparlo alla cartella del progetto e come avviare lo scripting sarà trattato nel capitolo webDriver.
Cos'è il selenio RC?
Selenium Remote Control (RC) è stato il principale progetto Selenium che è durato a lungo prima che Selenium WebDriver (Selenium 2.0) venisse all'esistenza. Ora Selenium RC è poco utilizzato, poiché WebDriver offre funzionalità più potenti, tuttavia gli utenti possono ancora continuare a sviluppare script utilizzando RC.
Ci consente di scrivere test dell'interfaccia utente di applicazioni web automatizzati con l'aiuto della piena potenza dei linguaggi di programmazione come Java, C #, Perl, Python e PHP per creare test più complessi come leggere e scrivere file, interrogare un database e inviare i risultati dei test tramite e-mail .
Architettura RC selenio
Selenium RC funziona in modo tale che le librerie client possano comunicare con Selenium RC Server passando ogni comando Selenium per l'esecuzione. Quindi il server passa il comando Selenium al browser utilizzando i comandi JavaScript Selenium-Core.
Il browser esegue il comando Selenium utilizzando il suo interprete JavaScript.
Selenium RC è disponibile in due parti.
Il Selenium Server avvia e uccide i browser. Oltre a ciò, interpreta ed esegue i comandi Selenese. Funziona anche come proxy HTTP intercettando e verificando i messaggi HTTP passati tra il browser e l'applicazione sotto test.
Librerie client che forniscono un'interfaccia tra ciascuno dei linguaggi di programmazione (Java, C #, Perl, Python e PHP) e Selenium-RC Server.
Scripting RC
Ora scriviamo uno script di esempio utilizzando Selenium Remote Control. Usiamohttp://www.calculator.net/per capire Selenio RC. Eseguiremo un calcolo percentuale utilizzando il "Calcolatore percentuale" presente nel modulo "Calcolatori matematici".
Step 1 - Avvia Selenium Remote Control (con l'aiuto del prompt dei comandi).
Step 2 - Dopo aver avviato Selenium RC, apri Eclipse e crea un "Nuovo progetto" come mostrato di seguito.
Step 3 - Immettere il nome del progetto e fare clic sul pulsante "Avanti".
Step 4 - Verifica la cartella Sorgente, Progetti, Librerie e Output e fai clic su "Fine".
Step 5 - Fare clic con il tasto destro sul contenitore "progetto" e scegliere "Configura percorso di compilazione".
Step 6- Si aprono le proprietà per "selrcdemo". Vai alla scheda "Librerie" e seleziona "Aggiungi JAR esterni". Scegli il file jar Selenium RC che abbiamo scaricato e apparirà come mostrato di seguito.
Step 7 - Le librerie a cui si fa riferimento vengono mostrate come mostrato di seguito.
Step 8 - Crea un nuovo file di classe facendo clic con il pulsante destro del mouse sulla cartella "src" e seleziona "Nuovo" >> "classe".
Step 9 - Immettere un nome per il file di classe e abilitare "public static void main" come mostrato di seguito.
Step 10 - La classe creata viene creata nella struttura delle cartelle come mostrato di seguito.
Step 11- Ora è il momento della codifica. Il codice seguente contiene commenti incorporati per far capire ai lettori cosa è stato presentato.
package selrcdemo;
import com.thoughtworks.selenium.DefaultSelenium;
import com.thoughtworks.selenium.Selenium;
public class rcdemo {
public static void main(String[] args) throws InterruptedException {
// Instatiate the RC Server
Selenium selenium = new DefaultSelenium("localhost", 4444 , "firefox", "http://www.calculator.net");
selenium.start(); // Start
selenium.open("/"); // Open the URL
selenium.windowMaximize();
// Click on Link Math Calculator
selenium.click("xpath = .//*[@id = 'menu']/div[3]/a");
Thread.sleep(2500); // Wait for page load
// Click on Link Percent Calculator
selenium.click("xpath = .//*[@id = 'menu']/div[4]/div[3]/a");
Thread.sleep(4000); // Wait for page load
// Focus on text Box
selenium.focus("name = cpar1");
// enter a value in Text box 1
selenium.type("css=input[name = \"cpar1\"]", "10");
// enter a value in Text box 2
selenium.focus("name = cpar2");
selenium.type("css = input[name = \"cpar2\"]", "50");
// Click Calculate button
selenium.click("xpath = .//*[@id = 'content']/table/tbody/tr/td[2]/input");
// verify if the result is 5
String result = selenium.getText(".//*[@id = 'content']/p[2]");
if (result == "5") {
System.out.println("Pass");
} else {
System.out.println("Fail");
}
}
}
Step 12 - Ora, eseguiamo lo script facendo clic sul pulsante "Esegui".
Step 13 - Lo script inizierà l'esecuzione e l'utente sarà in grado di vedere la cronologia dei comandi nella scheda "Cronologia comandi".
Step 14- Lo stato finale dell'applicazione è mostrato di seguito. La percentuale viene calcolata e il risultato viene visualizzato sullo schermo come mostrato di seguito.
Step 15- L'output del test viene stampato sulla console Eclipse come mostrato di seguito, poiché abbiamo stampato l'output sulla console. In tempo reale l'output viene scritto in un file HTML o in un semplice file di testo.
Un comando si riferisce a ciò che il selenio deve fare e i comandi nel selenio sono di tre tipi. Fare clic su ciascuno di essi per saperne di più sui comandi.
Localizzatori
Gli Element Locator aiutano Selenium a identificare l'elemento HTML a cui fa riferimento il comando. Tutti questi localizzatori possono essere identificati con l'aiuto di FirePath e FireBug plugin di Mozilla. Fare riferimento al capitolo Configurazione dell'ambiente per i dettagli.
identifier = id Seleziona l'elemento con l'attributo "id" specificato e se non c'è corrispondenza, seleziona il primo elemento il cui attributo @name è id.
id = id Seleziona l'elemento con l'attributo "id" specificato.
name = name Seleziona il primo elemento con l'attributo "nome" specificato
dom = javascriptExpressionSelenium trova un elemento valutando la stringa specificata che ci consente di attraversare il Document Object Model HTML utilizzando JavaScript. Gli utenti non possono restituire un valore ma possono valutare come un'espressione nel blocco.
xpath = xpathExpression Individua un elemento utilizzando un'espressione XPath.
link = textPattern Seleziona l'elemento link (all'interno dei tag di ancoraggio) che contiene il testo che corrisponde al modello specificato.
css = cssSelectorSyntax Seleziona l'elemento usando il selettore CSS.
WebDriver è uno strumento per automatizzare il test delle applicazioni web. È popolarmente noto come selenio 2.0. WebDriver utilizza un framework sottostante diverso, mentre Selenium RC utilizza JavaScript Selenium-Core incorporato nel browser che presenta alcune limitazioni. WebDriver interagisce direttamente con il browser senza alcun intermediario, a differenza di Selenium RC che dipende da un server. Viene utilizzato nel seguente contesto:
Test multi-browser che include funzionalità migliorate per i browser che non sono ben supportate da Selenium RC (Selenium 1.0).
Gestione di più frame, più finestre del browser, popup e avvisi.
Navigazione della pagina complessa.
Navigazione utente avanzata come il drag-and-drop.
Elementi dell'interfaccia utente basati su AJAX.
Architettura
WebDriver viene spiegato al meglio con un semplice diagramma dell'architettura come mostrato di seguito.
Selenio RC Vs WebDriver
Selenio RC | Selenium WebDriver |
---|---|
L'architettura di Selenium RC è complicata, poiché il server deve essere attivo e funzionante prima di iniziare un test. | L'architettura di WebDriver è più semplice di Selenium RC, poiché controlla il browser dal livello del sistema operativo. |
Il server Selenio funge da intermediario tra il browser ei comandi Selenese. | WebDriver interagisce direttamente con il browser e utilizza il motore del browser per controllarlo. |
L'esecuzione dello script Selenium RC è più lenta, poiché utilizza un Javascript per interagire con RC. | WebDriver è più veloce, poiché interagisce direttamente con il browser. |
Selenium RC non può supportare l'esecuzione senza testa in quanto necessita di un browser reale con cui lavorare. | WebDriver può supportare l'esecuzione senza testa. |
È un'API semplice e piccola. | API complessa e un po 'grande rispetto a RC. |
API meno orientata agli oggetti. | API puramente orientata agli oggetti. |
Impossibile testare le applicazioni mobili. | Può testare applicazioni per iPhone / Android. |
Scripting utilizzando WebDriver
Facci capire come lavorare con WebDriver. Per dimostrazione, useremmohttps://www.calculator.net/. Eseguiremo un "Calcolatore percentuale" che si trova sotto "Calcolatore matematico". Abbiamo già scaricato i JAR WebDriver richiesti. Fare riferimento al capitolo "Configurazione ambientale" per i dettagli.
Step 1 - Avvia "Eclipse" dalla cartella Extracted Eclipse.
Step 2 - Seleziona l'area di lavoro facendo clic sul pulsante "Sfoglia".
Step 3 - Ora crea un "Nuovo progetto" dal menu "File".
Step 4 - Immettere il nome del progetto e fare clic su "Avanti".
Step 5- Vai alla scheda Librerie e seleziona tutti i JAR che abbiamo scaricato. Aggiungi il riferimento a tutti i JAR della cartella Selenium WebDriver Library e anche selenium-java-2.42.2.jar e selenium-java-2.42.2-srcs.jar.
Step 6 - Il pacchetto viene creato come mostrato di seguito.
Step 7 - Ora fai clic con il pulsante destro del mouse sul pacchetto e seleziona "Nuovo" >> "Classe" per creare una "classe".
Step 8 - Ora dai un nome alla classe e rendila la funzione principale.
Step 9 - Lo schema della classe è mostrato come di seguito.
Step 10- Ora è il momento di programmare. Il seguente script è più facile da capire, poiché contiene commenti incorporati per spiegare chiaramente i passaggi. Dai un'occhiata al capitolo "Localizzatori" per capire come catturare le proprietà degli oggetti.
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
public class webdriverdemo {
public static void main(String[] args) {
WebDriver driver = new FirefoxDriver();
//Puts an Implicit wait, Will wait for 10 seconds before throwing exception
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
//Launch website
driver.navigate().to("http://www.calculator.net/");
//Maximize the browser
driver.manage().window().maximize();
// Click on Math Calculators
driver.findElement(By.xpath(".//*[@id = 'menu']/div[3]/a")).click();
// Click on Percent Calculators
driver.findElement(By.xpath(".//*[@id = 'menu']/div[4]/div[3]/a")).click();
// Enter value 10 in the first number of the percent Calculator
driver.findElement(By.id("cpar1")).sendKeys("10");
// Enter value 50 in the second number of the percent Calculator
driver.findElement(By.id("cpar2")).sendKeys("50");
// Click Calculate Button
driver.findElement(By.xpath(".//*[@id = 'content']/table/tbody/tr[2]/td/input[2]")).click();
// Get the Result Text based on its xpath
String result =
driver.findElement(By.xpath(".//*[@id = 'content']/p[2]/font/b")).getText();
// Print a Log In message to the screen
System.out.println(" The Result is " + result);
//Close the Browser.
driver.close();
}
}
Step 11 - L'output dello script precedente verrà stampato in Console.
Comandi più utilizzati
La tabella seguente elenca alcuni dei comandi utilizzati più di frequente in WebDriver insieme alla loro sintassi.
Sr.No. | Comando e descrizione |
---|---|
1 | driver.get("URL") Per passare a un'applicazione. |
2 | element.sendKeys("inputtext") Immettere del testo in una casella di input. |
3 | element.clear() Cancella il contenuto dalla casella di input. |
4 | select.deselectAll() Deseleziona tutte le OPZIONI dalla prima SELEZIONE nella pagina. |
5 | select.selectByVisibleText("some text") Selezionare l'OPZIONE con l'ingresso specificato dall'utente. |
6 | driver.switchTo().window("windowName") Spostare lo stato attivo da una finestra all'altra. |
7 | driver.switchTo().frame("frameName") Oscilla da un fotogramma all'altro. |
8 | driver.switchTo().alert() Aiuta a gestire gli avvisi. |
9 | driver.navigate().to("URL") Vai all'URL. |
10 | driver.navigate().forward() Per andare avanti. |
11 | driver.navigate().back() Per tornare indietro. |
12 | driver.close() Chiude il browser corrente associato al driver. |
13 | driver.quit() Esce dal driver e chiude tutte le finestre associate a quel driver. |
14 | driver.refresh() Aggiorna la pagina corrente. |
L'individuazione degli elementi in Selenium WebDriver viene eseguita con l'aiuto dei metodi findElement () e findElements () forniti da WebDriver e dalla classe WebElement.
findElement () restituisce un oggetto WebElement in base a un criterio di ricerca specificato o finisce per generare un'eccezione se non trova alcun elemento corrispondente ai criteri di ricerca.
findElements () restituisce un elenco di WebElements che corrispondono ai criteri di ricerca. Se non vengono trovati elementi, restituisce un elenco vuoto.
La tabella seguente elenca tutta la sintassi Java per l'individuazione degli elementi in Selenium WebDriver.
Metodo | Sintassi | Descrizione |
---|---|---|
Per ID | driver.findElement (By.id (<ID elemento>)) | Individua un elemento utilizzando l'attributo ID |
Per nome | driver.findElement (By.name (<nome elemento>)) | Individua un elemento utilizzando l'attributo Name |
Per nome della classe | driver.findElement (By.className (<element class>)) | Individua un elemento utilizzando l'attributo Class |
Per nome del tag | driver.findElement (By.tagName (<htmltagname>)) | Individua un elemento utilizzando il tag HTML |
Tramite testo del collegamento | driver.findElement (By.linkText (<linktext>)) | Individua un collegamento utilizzando il testo del collegamento |
Dal testo del collegamento parziale | driver.findElement (By.partialLinkText (<linktext>)) | Individua un collegamento utilizzando il testo parziale del collegamento |
Di CSS | driver.findElement (By.cssSelector (<css selector>)) | Individua un elemento utilizzando il selettore CSS |
Di XPath | driver.findElement (By.xpath (<xpath>)) | Individua un elemento utilizzando la query XPath |
Utilizzo dei localizzatori
Ora comprendiamo l'uso pratico di ciascuno dei metodi di localizzazione con l'aiuto di https://www.calculator.net
Per ID
Qui si accede a un oggetto con l'aiuto degli ID. In questo caso, è l'ID della casella di testo. I valori vengono inseriti nella casella di testo utilizzando il metodo sendkeys con l'aiuto di ID (cdensity).
driver.findElement(By.id("cdensity")).sendKeys("10");
Per nome
Qui si accede a un oggetto con l'aiuto dei nomi. In questo caso, è il nome della casella di testo. I valori vengono inseriti nella casella di testo utilizzando il metodo sendkeys con l'aiuto di ID (cdensity).
driver.findElement(By.name("cdensity")).sendKeys("10");
Per nome della classe
Qui si accede a un oggetto con l'aiuto dei nomi di classe. In questo caso, è il nome della classe di WebElement. È possibile accedere al valore con l'aiuto del metodo gettext.
List<WebElement> byclass = driver.findElements(By.className("smalltext smtb"));
Per nome tag
Il nome tag DOM di un elemento può essere utilizzato per individuare quel particolare elemento nel WebDriver. È molto facile gestire le tabelle con l'aiuto di questo metodo. Dai un'occhiata al seguente codice.
WebElement table = driver.findElement(By.id("calctable"));
List<WebElement> row = table.findElements(By.tagName("tr"));
int rowcount = row.size();
Per testo del collegamento
Questo metodo aiuta a individuare un elemento di collegamento con testo visibile corrispondente.
driver.findElements(By.linkText("Volume")).click();
Dal testo del collegamento parziale
Questo metodo consente di individuare un elemento di collegamento con testo visibile corrispondente parziale.
driver.findElement(By.partialLinkText("Volume")).click();
Di CSS
Il CSS viene utilizzato come metodo per identificare il webobject, tuttavia NON tutti i browser supportano l'identificazione CSS.
WebElement loginButton = driver.findElement(By.cssSelector("input.login"));
Di XPath
XPath è l'acronimo di XML path language. È un linguaggio di query per selezionare i nodi da un documento XML. XPath si basa sulla rappresentazione ad albero dei documenti XML e offre la possibilità di spostarsi all'interno dell'albero selezionando i nodi utilizzando una varietà di criteri.
driver.findElement(By.xpath(".//*[@id = 'content']/table[1]/tbody/tr/td/table/tbody/tr[2]/td[1]/input")).sendkeys("100");
Selenium WebDriver è lo strumento più utilizzato tra tutti gli strumenti disponibili nel set di strumenti Selenium. Pertanto è importante capire come utilizzare Selenium per interagire con le app web. In questo modulo, vediamo come interagire con gli oggetti GUI utilizzando Selenium webDriver.
Abbiamo bisogno di interagire con l'applicazione utilizzando alcune azioni di base o anche alcune azioni utente avanzate sviluppando funzioni definite dall'utente per le quali non esistono comandi predefiniti.
Di seguito sono elencati i diversi tipi di azioni contro questi oggetti GUI:
Ci sono vari componenti coinvolti nella progettazione dei test. Comprendiamo anche alcuni dei componenti importanti coinvolti nella progettazione di un framework. Impareremo i seguenti argomenti in questo capitolo:
TestNG è un potente framework di test, una versione migliorata di JUnit che era in uso da molto tempo prima che TestNG fosse nato. NG sta per "Next Generation".
Il framework TestNG fornisce le seguenti funzionalità:
- Le annotazioni ci aiutano a organizzare facilmente i test.
- Configurazione flessibile del test.
- I casi di test possono essere raggruppati più facilmente.
- La parallelizzazione dei test può essere ottenuta utilizzando TestNG.
- Supporto per test basati sui dati.
- Reportistica integrata.
Installazione di TestNG per Eclipse
Step 1 - Avvia Eclipse e seleziona "Installa nuovo software".
Step 2 - Immettere l'URL come "http://beust.com/eclipse" e fare clic su "Aggiungi".
Step 3- Si apre la finestra di dialogo "Aggiungi repository". Immettere il nome come "TestNG" e fare clic su "OK"
Step 4 - Fare clic su "Seleziona tutto" per selezionare "TestNG" come mostrato nella figura.
Step 5 - Fare clic su "Avanti" per continuare.
Step 6 - Rivedi gli elementi selezionati e fai clic su "Avanti".
Step 7 - "Accetta il contratto di licenza" e fai clic su "Fine".
Step 8 - TestNG inizia l'installazione e il progresso verrà mostrato di seguito.
Step 9- Viene visualizzato un avviso di sicurezza quando non è possibile stabilire la validità del software. Fare clic su "Ok".
Step 10- Il programma di installazione richiede di riavviare Eclipse affinché le modifiche abbiano effetto. Fare clic su "Sì".
Annotazioni in TestNG
Le annotazioni sono state aggiunte formalmente al linguaggio Java in JDK 5 e TestNG ha scelto di utilizzare le annotazioni per annotare le classi di test. Di seguito sono riportati alcuni dei vantaggi dell'utilizzo delle annotazioni. Ulteriori informazioni su TestNG possono essere trovatehere
TestNG identifica i metodi a cui è interessato cercando le annotazioni. Quindi, i nomi dei metodi non sono limitati a nessun modello o formato.
Possiamo passare parametri aggiuntivi alle annotazioni.
Le annotazioni sono fortemente tipizzate, quindi il compilatore segnalerà immediatamente eventuali errori.
Le classi di test non devono più estendere nulla (come TestCase, per JUnit 3).
Sr.No. | Annotazione e descrizione |
---|---|
1 | @BeforeSuite Il metodo annotato verrà eseguito solo una volta prima che tutti i test in questa suite siano stati eseguiti. |
2 | @AfterSuite Il metodo annotato verrà eseguito solo una volta dopo che tutti i test in questa suite saranno stati eseguiti. |
3 | @BeforeClass Il metodo annotato verrà eseguito solo una volta prima che venga richiamato il primo metodo di test nella classe corrente. |
4 | @AfterClass Il metodo annotato verrà eseguito solo una volta dopo che tutti i metodi di test nella classe corrente saranno stati eseguiti. |
5 | @BeforeTest Il metodo annotato verrà eseguito prima di eseguire qualsiasi metodo di test appartenente alle classi all'interno del tag <test>. |
6 | @AfterTest Il metodo annotato verrà eseguito dopo che tutti i metodi di test appartenenti alle classi all'interno del tag <test> sono stati eseguiti. |
7 | @BeforeGroups L'elenco dei gruppi che questo metodo di configurazione eseguirà prima. È garantito che questo metodo venga eseguito poco prima che venga richiamato il primo metodo di prova che appartiene a uno di questi gruppi. |
8 | @AfterGroups L'elenco dei gruppi in base ai quali verrà eseguito questo metodo di configurazione. È garantito che questo metodo venga eseguito subito dopo che è stato richiamato l'ultimo metodo di test che appartiene a uno di questi gruppi. |
9 | @BeforeMethod Il metodo annotato verrà eseguito prima di ogni metodo di prova. |
10 | @AfterMethod Il metodo annotato verrà eseguito dopo ogni metodo di prova. |
11 | @DataProvider Contrassegna un metodo come fornitura di dati per un metodo di prova. Il metodo annotato deve restituire un Object [] [] dove a ciascun Object [] può essere assegnato l'elenco dei parametri del metodo di test. Il metodo @Test che desidera ricevere dati da questo DataProvider deve utilizzare un nome dataProvider uguale al nome di questa annotazione. |
12 | @Factory Contrassegna un metodo come factory che restituisce oggetti che verranno utilizzati da TestNG come classi Test. Il metodo deve restituire Object []. |
13 | @Listeners Definisce i listener in una classe di test. |
14 | @Parameters Descrive come passare i parametri a un metodo @Test. |
15 | @Test Contrassegna una classe o un metodo come parte del test. |
Configurazione TestNG-Eclipse
Step 1 - Avvia Eclipse e crea un "Nuovo progetto Java" come mostrato di seguito.
Step 2 - Immettere il nome del progetto e fare clic su "Avanti".
Step 3 - Passare alla scheda "Librerie" e aggiungere il file JAR Selenium Remote Control Server facendo clic su "Aggiungi JAR esterni" come mostrato di seguito.
Step 4- Il file JAR aggiunto viene mostrato qui. Fare clic su "Aggiungi libreria".
Step 5- Si apre la finestra di dialogo "Aggiungi libreria". Seleziona "TestNG" e fai clic su "Avanti" nella finestra di dialogo "Aggiungi libreria".
Step 6 - La libreria "TestNG" aggiunta viene aggiunta e viene visualizzata come mostrato di seguito.
Step 7 - Al momento della creazione del progetto, la struttura del progetto sarà come mostrato di seguito.
Step 8 - Fare clic con il tasto destro sulla cartella "src" e selezionare Nuovo >> Altro.
Step 9 - Seleziona "TestNG" e fai clic su "Avanti".
Step 10 - Seleziona il nome della "Cartella di origine" e fai clic su "Ok".
Step 11 - Seleziona il "Nome del pacchetto", il "nome della classe" e fai clic su "Fine".
Step 12 - Verranno visualizzati il Package explorer e la classe creata.
Primo test in TestNG
Ora iniziamo a creare script usando TestNG. Facciamo uno script per lo stesso esempio che abbiamo usato per comprendere il WebDriver. Useremo l'applicazione demo, www.calculator.net , ed eseguiremo il calcolo delle percentuali.
Nel seguente test, noterai che NON esiste un metodo principale, poiché testNG guiderà il flusso di esecuzione del programma. Dopo aver inizializzato il driver, eseguirà il metodo "@BeforeTest" seguito da "@Test" e quindi "@AfterTest". Tieni presente che in una classe può essere presente un numero qualsiasi di annotazioni "@Test", ma "@BeforeTest" e "@AfterTest" possono apparire solo una volta.
package TestNG;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
public class TestNGClass {
WebDriver driver = new FirefoxDriver();
@BeforeTest
public void launchapp() {
// Puts an Implicit wait, Will wait for 10 seconds before throwing exception
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
// Launch website
driver.navigate().to("http://www.calculator.net");
driver.manage().window().maximize();
}
@Test
public void calculatepercent() {
// Click on Math Calculators
driver.findElement(By.xpath(".//*[@id='menu']/div[3]/a")).click();
// Click on Percent Calculators
driver.findElement(By.xpath(".//*[@id='menu']/div[4]/div[3]/a")).click();
// Enter value 10 in the first number of the percent Calculator
driver.findElement(By.id("cpar1")).sendKeys("10");
// Enter value 50 in the second number of the percent Calculator
driver.findElement(By.id("cpar2")).sendKeys("50");
// Click Calculate Button
driver.findElement(By.xpath(".//*[@id='content']/table/tbody/tr/td[2]/input")).click();
// Get the Result Text based on its xpath
String result =
driver.findElement(By.xpath(".//*[@id='content']/p[2]/span/font/b")).getText();
// Print a Log In message to the screen
System.out.println(" The Result is " + result);
if(result.equals("5")) {
System.out.println(" The Result is Pass");
} else {
System.out.println(" The Result is Fail");
}
}
@AfterTest
public void terminatetest() {
driver.close();
}
}
Esecuzione
Per eseguire, fai clic con il pulsante destro del mouse sull'XML creato e seleziona "Esegui come" >> "TestNG Suite"
Analisi dei risultati
L'output viene lanciato nella console e apparirà come mostrato di seguito. L'output della console ha anche un riepilogo dell'esecuzione.
Il risultato di TestNG può essere visualizzato anche in una scheda diversa. Fare clic sul pulsante "Visualizzazione report HTML" come mostrato di seguito.
Il risultato HTML verrà visualizzato come mostrato di seguito.
Selenium Grid è uno strumento che distribuisce i test su più macchine fisiche o virtuali in modo da poter eseguire script in parallelo (simultaneamente). Accelera notevolmente il processo di test su browser e piattaforme, fornendoci feedback rapidi e accurati.
Selenium Grid ci consente di eseguire più istanze di test WebDriver o Selenium Remote Control in parallelo che utilizza la stessa base di codice, quindi il codice NON deve essere presente sul sistema che eseguono. Il pacchetto selenium-server-standalone include Hub, WebDriver e Selenium RC per eseguire gli script nella griglia.
Selenium Grid ha un Hub e un Nodo.
Hub- L'hub può anche essere inteso come un server che funge da punto centrale in cui verranno attivati i test. Una griglia di selenio ha un solo hub e viene lanciata su una singola macchina una volta.
Node- I nodi sono le istanze di Selenium che sono collegate all'Hub che esegue i test. Possono esserci uno o più nodi in una griglia che può essere di qualsiasi sistema operativo e può contenere uno qualsiasi dei browser supportati da Selenium.
Architettura
Il diagramma seguente mostra l'architettura di Selenium Grid.
Lavorare con Grid
Per poter lavorare con Grid, dobbiamo seguire alcuni protocolli. Ascolta di seguito sono i passaggi principali coinvolti in questo processo:
- Configurazione dell'hub
- Configurazione dei nodi
- Sviluppa lo script e prepara il file XML
- Esecuzione del test
- Analisi dei risultati
Discutiamo in dettaglio ciascuno di questi passaggi.
Configurazione dell'hub
Step 1 - Scarica l'ultimo file JAR autonomo di Selenium Server da http://docs.seleniumhq.org/download/. Scaricalo facendo clic sulla versione come mostrato di seguito.
Step 2- Avvia l'Hub avviando il Selenium Server utilizzando il seguente comando. Ora useremo la porta "4444" per avviare l'hub.
Note - Assicurati che non ci siano altre applicazioni in esecuzione sulla porta # 4444.
java -jar selenium-server-standalone-2.25.0.jar -port 4444 -role hub -nodeTimeout 1000
Step 3 - Ora apri il browser e vai all'URL http // localhost: 4444 dall'Hub (il sistema in cui hai eseguito il passaggio # 2).
Step 4- Ora fai clic sul link "console" e fai clic su "visualizza configurazione". La configurazione dell'hub verrebbe visualizzata come segue. Al momento, non abbiamo alcun nodo, quindi non saremo in grado di vedere i dettagli.
Configurazione dei nodi
Step 1- Accedi al nodo (dove desideri eseguire gli script) e inserisci "selenium-server-standalone-2.42.2" in una cartella. Dobbiamo puntare al JAR selenio-server-standalone durante l'avvio dei nodi.
Step 2 - Avvia FireFox Node utilizzando il seguente comando.
java -jar D:\JAR\selenium-server-standalone-2.42.2.jar
-role node -hub http://10.30.217.157:4444/grid/register
-browser browserName = firefox -port 5555
Dove,
D: \ JAR \ selenium-server-standalone-2.42.2.jar = Posizione del file Jar Standalone Selenium Server (sulla macchina del nodo)
http://10.30.217.157:4444 = Indirizzo IP dell'Hub e 4444 è la porta dell'Hub
browserName = firefox (parametro per specificare il nome del browser sui nodi)
5555 = Porta su cui Firefox Node sarebbe attivo e funzionante.
Step 3- Dopo aver eseguito il comando, torna all'Hub. Vai all'URL - http://10.30.217.157:4444 e l'hub ora visualizzerà il nodo ad esso collegato.
Step 4- Ora lanciamo il nodo Internet Explorer. Per avviare IE Node, è necessario che il driver di Internet Explorer sia scaricato sulla macchina del nodo.
Step 5 - Per scaricare il driver di Internet Explorer, accedere a http://docs.seleniumhq.org/download/e scarica il file appropriato in base all'architettura del tuo sistema operativo. Dopo aver scaricato, decomprimere il file exe e inserire in esso una cartella a cui fare riferimento durante l'avvio dei nodi IE.
Step 6 - Avvia IE utilizzando il seguente comando.
C:\>java -Dwebdriver.ie.driver = D:\IEDriverServer.exe
-jar D:\JAR\selenium-server-standalone-2.42.2.jar
-role webdriver -hub http://10.30.217.157:4444/grid/register
-browser browserName = ie,platform = WINDOWS -port 5558
Dove,
D: \ IEDriverServer.exe = La posizione del driver IE scaricato (sulla macchina del nodo)
D: \ JAR \ selenium-server-standalone-2.42.2.jar = Posizione del file Jar Standalone Selenium Server (sulla macchina del nodo)
http://10.30.217.157:4444 = Indirizzo IP dell'Hub e 4444 è la porta dell'Hub
browserName = ie (parametro per specificare il nome del browser sui nodi)
5558 = Porta su cui IE Node sarebbe attivo e funzionante.
Step 7- Dopo aver eseguito il comando, torna all'Hub. Vai all'URL - http://10.30.217.157:4444 e l'hub ora visualizzerà il nodo IE ad esso collegato.
Step 8- Ora lanciamo Chrome Node. Per avviare il nodo Chrome, è necessario che il driver Chrome venga scaricato sul computer del nodo.
Step 9 - Per scaricare il driver Chrome, vai a http://docs.seleniumhq.org/download/ quindi accedere all'area Driver del browser di terze parti e fare clic sul numero di versione "2.10" come mostrato di seguito.
Step 10- Scarica il driver in base al tipo di sistema operativo. Lo eseguiremo su ambiente Windows, quindi scaricheremo il driver di Windows Chrome. Dopo aver scaricato, decomprimere il file exe e posizionarlo in una cartella a cui fare riferimento durante l'avvio dei nodi Chrome.
Step 11 - Avvia Chrome utilizzando il seguente comando.
C:\>java -Dwebdriver.chrome.driver = D:\chromedriver.exe
-jar D:\JAR\selenium-server-standalone-2.42.2.jar
-role webdriver -hub http://10.30.217.157:4444/grid/register
-browser browserName = chrome, platform = WINDOWS -port 5557
Dove,
D: \ chromedriver.exe = La posizione del driver chrome scaricato (sulla macchina del nodo)
D: \ JAR \ selenium-server-standalone-2.42.2.jar = Posizione del file Jar Standalone Selenium Server (sulla macchina del nodo)
http://10.30.217.157:4444 = Indirizzo IP dell'Hub e 4444 è la porta dell'Hub
browserName = chrome (parametro per specificare il nome del browser sui nodi)
5557 = Porta su cui Chrome Node sarebbe attivo e funzionante.
Step 12- Dopo aver eseguito il comando, torna all'Hub. Vai all'URL - http://10.30.217.157:4444 e l'Hub ora visualizzerà il nodo chrome ad esso collegato.
Sviluppa lo script e prepara il file XML
Step 1- Svilupperemo un test utilizzando TestNG. Nel seguente esempio, avvieremo ciascuno di questi browser utilizzando webDriver remoto. Può trasmettere le loro capacità al driver in modo che il driver abbia tutte le informazioni da eseguire sui nodi.
Il parametro del browser verrebbe passato dal file "XML".
package TestNG;
import org.openqa.selenium.*;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;
import java.net.URL;
import java.util.concurrent.TimeUnit;
import java.net.MalformedURLException;
public class TestNGClass {
public WebDriver driver;
public String URL, Node;
protected ThreadLocal<RemoteWebDriver> threadDriver = null;
@Parameters("browser")
@BeforeTest
public void launchapp(String browser) throws MalformedURLException {
String URL = "http://www.calculator.net";
if (browser.equalsIgnoreCase("firefox")) {
System.out.println(" Executing on FireFox");
String Node = "http://10.112.66.52:5555/wd/hub";
DesiredCapabilities cap = DesiredCapabilities.firefox();
cap.setBrowserName("firefox");
driver = new RemoteWebDriver(new URL(Node), cap);
// Puts an Implicit wait, Will wait for 10 seconds before throwing exception
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
// Launch website
driver.navigate().to(URL);
driver.manage().window().maximize();
} else if (browser.equalsIgnoreCase("chrome")) {
System.out.println(" Executing on CHROME");
DesiredCapabilities cap = DesiredCapabilities.chrome();
cap.setBrowserName("chrome");
String Node = "http://10.112.66.52:5557/wd/hub";
driver = new RemoteWebDriver(new URL(Node), cap);
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
// Launch website
driver.navigate().to(URL);
driver.manage().window().maximize();
} else if (browser.equalsIgnoreCase("ie")) {
System.out.println(" Executing on IE");
DesiredCapabilities cap = DesiredCapabilities.chrome();
cap.setBrowserName("ie");
String Node = "http://10.112.66.52:5558/wd/hub";
driver = new RemoteWebDriver(new URL(Node), cap);
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
// Launch website
driver.navigate().to(URL);
driver.manage().window().maximize();
} else {
throw new IllegalArgumentException("The Browser Type is Undefined");
}
}
@Test
public void calculatepercent() {
// Click on Math Calculators
driver.findElement(By.xpath(".//*[@id = 'menu']/div[3]/a")).click();
// Click on Percent Calculators
driver.findElement(By.xpath(".//*[@id = 'menu']/div[4]/div[3]/a")).click();
// Enter value 10 in the first number of the percent Calculator
driver.findElement(By.id("cpar1")).sendKeys("10");
// Enter value 50 in the second number of the percent Calculator
driver.findElement(By.id("cpar2")).sendKeys("50");
// Click Calculate Button
// driver.findElement(By.xpath(".//*[@id = 'content']/table/tbody/tr/td[2]/input")).click();
// Get the Result Text based on its xpath
String result =
driver.findElement(By.xpath(".//*[@id = 'content']/p[2]/span/font/b")).getText();
// Print a Log In message to the screen
System.out.println(" The Result is " + result);
if(result.equals("5")) {
System.out.println(" The Result is Pass");
} else {
System.out.println(" The Result is Fail");
}
}
@AfterTest
public void closeBrowser() {
driver.quit();
}
}
Step 2- Il parametro Browser verrà passato utilizzando XML. Crea un XML nella cartella del progetto.
Step 3 - Selezionare "File" da "Generale" e fare clic su "Avanti".
Step 4 - Immettere il nome del file e fare clic su "Fine".
Step 5 - TestNg.XML viene creato nella cartella del progetto come mostrato di seguito.
Step 6- Il contenuto del file XML è mostrato di seguito. Creiamo 3 test e li mettiamo in una suite e menzioniamo parallel = "test" in modo che tutti i test vengano eseguiti in parallelo.
<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name = "Suite" parallel = "tests">
<test name = "FirefoxTest">
<parameter name = "browser" value = "firefox" />
<classes>
<class name = "TestNG.TestNGClass" />
</classes>
</test>
<test name = "ChromeTest">
<parameter name = "browser" value = "chrome" />
<classes>
<class name = "TestNG.TestNGClass" />
</classes>
</test>
<test name = "IETest">
<parameter name = "browser" value = "ie" />
<classes>
<class name = "TestNG.TestNGClass" />
</classes>
</test>
</suite>
Esecuzione del test
Step 1- Seleziona l'XML creato; fare clic con il tasto destro e scegliere "Esegui come" >> "TestNG Suite".
Step 2- Ora apri il nodo, dove abbiamo avviato tutti i nodi del browser. Vedrai tutti e tre i browser in esecuzione contemporaneamente.
Analisi dei risultati
Step 1- Al termine dell'esecuzione, possiamo analizzare il risultato come qualsiasi altra esecuzione. Il riepilogo dei risultati viene stampato nella console come mostrato nella seguente istantanea.
Step 2 - Vai alla scheda "Risultati della suite in esecuzione" e TestNG visualizzerà il riepilogo dei risultati come mostrato di seguito.
Step 3 - Dopo aver generato l'HTML, saremo in grado di vedere i risultati del test in formato HTML.