Apache ANT con Selenium: Esercitazione completa
Krishna rungta
Cos'è Apache Ant?
Durante la creazione di un prodotto software completo, è necessario occuparsi delle diverse API di terze parti, del loro percorso di classe, della pulizia dei file binari eseguibili precedenti, della compilazione del nostro codice sorgente, dell'esecuzione del codice sorgente, della creazione di report e della base di codice di distribuzione ecc. Se queste attività sono eseguiti manualmente uno per uno, ci vorrà molto tempo e il processo sarà soggetto a errori.
Ecco l'importanza di uno strumento di costruzione come Ant. Memorizza, esegue e automatizza tutti i processi in un ordine sequenziale menzionato nel file di configurazione di Ant (solitamente build.xml).
Vantaggio della build Ant
- Ant crea il ciclo di vita dell'applicazione, ovvero pulizia, compilazione, impostazione delle dipendenze, esecuzione, report, ecc.
- La dipendenza API di terze parti può essere impostata da Ant, ovvero il percorso classe di un altro file Jar è impostato dal file di build Ant.
- Viene creata un'applicazione completa per la consegna e la distribuzione end-to-end.
- È un semplice strumento di creazione in cui tutte le configurazioni possono essere eseguite utilizzando un file XML e che può essere eseguito dalla riga di comando.
- Rende il tuo codice pulito poiché la configurazione è separata dalla logica dell'applicazione effettiva.
Come installare Ant
Passaggi per installare Ant Windows è come segue
Passo 1) Vai su https://ant.apache.org/bindownload.cgi Oppure scarica il file .zip da apache-ant-1.9.4-bin.zip
Passo 2) Decomprimere la cartella e andare a copiare il percorso nella radice della cartella decompressa
Passo 3) Vai su Start -> Computer -> fai clic con il pulsante destro del mouse qui e seleziona "Proprietà", quindi fai clic su Impostazioni di sistema avanzate
Passo 4) Si apre una nuova finestra. Fare clic sul pulsante "Variabile d'ambiente...".
Passo 5) Fare clic sul pulsante "Nuovo..." e impostare il nome della variabile come "ANT_HOME" e il valore della variabile come percorso principale della cartella decompressa e fare clic su OK.
Passo 6) ora seleziona la variabile "Percorso" dall'elenco, fai clic su "Modifica" e aggiungi; %ANT_HOME%\bin.
Riavvia il sistema una volta e sarai pronto per utilizzare lo strumento di creazione Ant ora.
Passo 7) Per verificare la versione di Ant utilizzando la riga di comando:
Versione formica
Comprendere Build.xml
Build.xml è il componente più importante dello strumento di creazione Ant. Per un Java progetto, tutte le attività correlate alla pulizia, configurazione, compilazione e distribuzione sono menzionate in questo file in formato XML. Quando eseguiamo questo file XML utilizzando la riga di comando o qualsiasi plug-in IDE, tutte le istruzioni scritte in questo file verranno eseguite in modo sequenziale.
Comprendiamo il codice all'interno di un build.XML di esempio
-
Il tag di progetto viene utilizzato per menzionare il nome di un progetto e l'attributo basedir. Basedir è la directory root di un'applicazione
<project name="YTMonetize" basedir=".">
- I tag delle proprietà vengono utilizzati come variabili nel file build.XML da utilizzare nei passaggi successivi
<property name="build.dir" value="${basedir}/build"/>
<property name="external.jars" value=".\resources"/>
<property name="ytoperation.dir" value="${external.jars}/YTOperation"/>
<property name="src.dir"value="${basedir}/src"/>
- Target tag usati come passaggi che verranno eseguiti in ordine sequenziale. L'attributo Name è il nome del target. Puoi avere più target in un singolo build.xml
<target name="setClassPath">
- Il tag path viene utilizzato per raggruppare logicamente tutti i file che si trovano nella posizione comune
<path id="classpath_jars">
- Il tag pathelement imposterà il percorso alla radice della posizione comune in cui sono archiviati tutti i file
<pathelement path="${basedir}/"/> - tag pathconvert utilizzato per convertire i percorsi di tutti i file comuni all'interno del tag path nel formato classpath del sistema
<pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>
- tag fileset utilizzato per impostare il percorso di classe per diversi jar di terze parti nel nostro progetto
<fileset dir="${ytoperation.dir}" includes="*.jar"/> - Il tag Echo viene utilizzato per stampare il testo sulla console
<echo message="deleting existing build directory"/>
- Elimina tag pulirà i dati da una determinata cartella
<delete dir="${build.dir}"/>
- Il tag mkdir creerà una nuova directory
<mkdir dir="${build.dir}"/>
- tag javac utilizzato per compilare il codice sorgente Java e spostare i file .class in una nuova cartella
<javac destdir="${build.dir}" srcdir="${src.dir}">
<classpath refid="classpath_jars"/>
</javac>
- Il tag jar creerà il file jar dai file .class
<jar destfile="${ytoperation.dir}/YTOperation.jar" basedir="${build.dir}">
- Il tag manifest imposterà la tua classe principale per l'esecuzione
<manifest> <attribute name="Main-Class" value="test.Main"/> </manifest>
- Attributo 'depends' utilizzato per far sì che un target dipenda da un altro target
<target name="run" depends="compile">
- Il tag Java eseguirà la funzione principale dal jar creato nella sezione di destinazione della compilazione
<java jar="${ytoperation.dir}/YTOperation.jar" fork="true"/>
Esegui Ant utilizzando Eclipse plug-in
Per eseguire Ant da Eclipse vai al file build.xml -> fai clic con il pulsante destro del mouse sul file -> Esegui come… -> fai clic su File di build
Esempio
Prenderemo un piccolo programma di esempio che spiegherà molto chiaramente la funzionalità di Ant. La struttura del nostro progetto sarà simile a:
Qui in questo esempio abbiamo 4 target
- Imposta il percorso della classe per i jar esterni,
- Pulisci il codice precedentemente compilato
- Compila il codice Java esistente
- Esegui il codice
Guru99AntClass.class
package testAnt;
import java.util.Date;
public class Guru99AntClass {
public static void main(String...s){
System.out.println("HELLO GURU99 ANT PROGRAM");
System.out.println("TODAY's DATE IS->"+ currentDate() );
}
public static String currentDate(){
return new Date().toString();
}
}
Build.xml
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!--Project tag used to mention the project name, and basedir attribute will be the root directory of the application-->
<project name="YTMonetize" basedir=".">
<!--Property tags will be used as variables in build.xml file to use in further steps-->
<property name="build.dir" value="${basedir}/build"/>
<property name="external.jars" value=".\resources"/>
<property name="ytoperation.dir" value="${external.jars}/YTOperation"/>
<property name="src.dir"value="${basedir}/src"/>
<!--Target tags used as steps that will execute in sequential order. name attribute will be the name of the target and < a name=OLE_LINK1 >'depends' attribute used to make one target to depend on another target -->
<target name="setClassPath">
<path id="classpath_jars">
<pathelement path="${basedir}/"/>
</path>
<pathconvert pathsep=";"property="test.classpath" refid="classpath_jars"/>
</target>
<target name="clean">
<!--echo tag will use to print text on console-->
<echo message="deleting existing build directory"/>
<!--delete tag will clean data from given folder-->
<delete dir="${build.dir}"/>
</target>
<target name="compile" depends="clean,setClassPath">
<echo message="classpath:${test.classpath}"/>
<echo message="compiling.........."/>
<!--mkdir tag will create new director-->
<mkdir dir="${build.dir}"/>
<echo message="classpath:${test.classpath}"/>
<echo message="compiling.........."/>
<!--javac tag used to compile java source code and move .class files to a new folder-->
<javac destdir="${build.dir}" srcdir="${src.dir}">
<classpath refid="classpath_jars"/>
</javac>
<!--jar tag will create jar file from .class files-->
<jar destfile="${ytoperation.dir}/YTOperation.jar"basedir="${build.dir}">
<!--manifest tag will set your main class for execution-->
<manifest>
<attribute name="Main-Class" value="testAnt.Guru99AntClass"/>
</manifest>
</jar>
</target>
<target name="run" depends="compile">
<!--java tag will execute main function from the jar created in compile target section-->
<java jar="${ytoperation.dir}/YTOperation.jar"fork="true"/>
</target>
</project>
Come eseguire TestNG codice utilizzando Ant
Qui creeremo una classe con Test metodi e impostare il percorso della classe per Testing nel file build.xml.
Ora per eseguire il metodo testng creeremo un altro file testng.xml e chiameremo questo file dal file build.xml.
Passo 1) Creiamo un file “Guru99AntClass.class” nel pacchetto testAnt
Guru99AntClass.class
package testAnt;
import java.util.Date;
import org.testng.annotations.Test;
public class Guru99AntClass {
@Test
public void Guru99AntTestNGMethod(){
System.out.println("HELLO GURU99 ANT PROGRAM");
System.out.println("TODAY's DATE IS->"+ currentDate() );
}
public static String currentDate(){
return new Date().toString();
}
}
Passaggio 2) Crea una destinazione per caricare questa classe in Build.xml
<!-- Load testNG and add to the class path of application -->
<target name="loadTestNG" depends="setClassPath">
<!—using taskdef tag we can add a task to run on the current project. In below line, we are adding testing task in this project. Using testing task here now we can run testing code using the ant script -->
<taskdef resource="testngtasks" classpath="${test.classpath}"/>
</target>
Passo 3) Crea testng.xml
testng.xml
<?xml version="1.0"encoding="UTF-8"?> <!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd"> <suite name="YT"thread-count="1"> <test name="GURU99TestNGAnt"> <classes> <class name="testAnt.Guru99AntClass"> </class> </classes> </test> </suite>
Passo 4) Creare Target in Build.xml per eseguirlo TestNG codice
<target name="runGuru99TestNGAnt" depends="compile">
<!-- testng tag will be used to execute testng code using corresponding testng.xml file. Here classpath attribute is setting classpath for testng's jar to the project-->
<testng classpath="${test.classpath};${build.dir}">
<!—xmlfileset tag is used here to run testng's code using testing.xml file. Using includes tag we are mentioning path to testing.xml file-->
<xmlfileset dir="${basedir}" includes="testng.xml"/>
</testng>
Passo 5) Il file Build.xml completo
<?xml version="1.0"encoding="UTF-8"standalone="no"?>
<!--Project tag used to mention the project name, and basedir attribute will be the root directory of the application-->
<project name="YTMonetize" basedir=".">
<!--Property tags will be used as variables in build.xml file to use in further steps-->
<property name="build.dir"value="${basedir}/build"/>
<!-- put testng related jar in the resource folder -->
<property name="external.jars" value=".\resource"/>
<property name="src.dir" value="${basedir}/src"/>
<!--Target tags used as steps that will execute in sequential order. name attribute will be the name
of the target and 'depends' attribute used to make one target to depend on another target-->
<!-- Load testNG and add to the class path of application -->
<target name="loadTestNG"depends="setClassPath">
<taskdef resource="testngtasks"classpath="${test.classpath}"/>
</target>
<target name="setClassPath">
<path id="classpath_jars">
<pathelement path="${basedir}/"/>
<fileset dir="${external.jars}" includes="*.jar"/>
</path>
<pathconvert pathsep=";"property="test.classpath"refid="classpath_jars"/>
</target>
<target name="clean">
<!--echo tag will use to print text on console-->
<echo message="deleting existing build directory"/>
<!--delete tag will clean data from given folder-->
<delete dir="${build.dir}"/>
</target>
<target name="compile"depends="clean,setClassPath,loadTestNG">
<echo message="classpath:${test.classpath}"/>
<echo message="compiling.........."/>
<!--mkdir tag will create new director-->
<mkdir dir="${build.dir}"/>
<echo message="classpath:${test.classpath}"/>
<echo message="compiling.........."/>
<!--javac tag used to compile java source code and move .class files to a new folder-->
<javac destdir="${build.dir}"srcdir="${src.dir}">
<classpath refid="classpath_jars"/>
</javac>
</target>
<target name="runGuru99TestNGAnt"depends="compile">
<!-- testng tag will be used to execute testng code using corresponding testng.xml file -->
<testng classpath="${test.classpath};${build.dir}">
<xmlfileset dir="${basedir}"includes="testng.xml"/>
</testng>
</target>
</project>
Passo 6) Uscita
Formica con Selenium Webdriver
Finora abbiamo imparato che utilizzando ANT possiamo inserire tutti i jar di terze parti in una posizione particolare nel sistema e impostare il loro percorso per il nostro progetto. Utilizzando questo metodo impostiamo tutte le dipendenze del nostro progetto in un unico posto e lo rendiamo più affidabile per la compilazione, l'esecuzione e la distribuzione.
Allo stesso modo, per i nostri progetti di test che utilizzano il selenio, possiamo facilmente menzionare la dipendenza dal selenio in build.xml e non abbiamo bisogno di aggiungerne manualmente un percorso di classe nella nostra applicazione.
Quindi ora puoi ignorare il modo tradizionale indicato di seguito per impostare i percorsi di classe per il progetto.
Esempio:
Modificheremo l'esempio precedente
Passo 1) Imposta la proprietà selenium.jars sul jar correlato al selenio nella cartella delle risorse
<property name="selenium.jars" value=".\selenium"/>
Passo 2) Nel setClassPath di destinazione aggiungere i file selenium
<target name="setClassPath">
<path id="classpath_jars">
<pathelement path="${basedir}/"/>
<fileset dir="${external.jars}" includes="*.jar"/>
<!-- selenium jar added here -->
<fileset dir="${selenium.jars}" includes="*.jar"/>
</path>
Passo 3) Completa Build.xml:
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!--Project tag used to mention the project name, and basedir attribute will be the root directory of the application-->
<project name="YTMonetize" basedir=".">
<!--Property tags will be used as variables in build.xml file to use in further steps-->
<property name="build.dir" value="${basedir}/build"/>
<!-- put testng related jar in the resource folder -->
<property name="external.jars" value=".\resource"/>
<!-- put selenium related jar in resource folder -->
<property name="selenium.jars" value=".\selenium"/>
<property name="src.dir" value="${basedir}/src"/>
<!--Target tags used as steps that will execute in sequential order. name attribute will be the name
of the target and 'depends' attribute used to make one target to depend on another target-->
<!-- Load testNG and add to the class path of application -->
<target name="loadTestNG" depends="setClassPath">
<taskdef resource="testngtasks" classpath="${test.classpath}"/>
</target>
<target name="setClassPath">
<path id="classpath_jars">
<pathelement path="${basedir}/"/>
<fileset dir="${external.jars}" includes="*.jar"/>
<!-- selenium jar added here -->
<fileset dir="${selenium.jars}"includes="*.jar"/>
</path>
<pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>
</target>
<target name="clean">
<!--echo tag will use to print text on console-->
<echo message="deleting existing build directory"/>
<!--delete tag will clean data from given folder-->
<delete dir="${build.dir}"/>
</target>
<target name="compile" depends="clean,setClassPath,loadTestNG">
<echo message="classpath:${test.classpath}"/>
<echo message="compiling.........."/>
<!--mkdir tag will create new director-->
<mkdir dir="${build.dir}"/>
<echo message="classpath:${test.classpath}"/>
<echo message="compiling.........."/>
<!--javac tag used to compile java source code and move .class files to new folder-->
<javac destdir="${build.dir}"srcdir="${src.dir}">
<classpath refid="classpath_jars"/>
</javac>
</target>
<target name="runGuru99TestNGAnt" depends="compile">
<!-- testng tag will be used to execute testng code using corresponding testng.xml file -->
<testng classpath="${test.classpath};${build.dir}">
<xmlfileset dir="${basedir}" includes="testng.xml"/>
</testng>
</target>
</project>
Passo 4) Ora cambia la classe Guru99AntClass.java creata in precedenza con il nuovo codice.
Ecco in questo esempio i nostri passaggi utilizzando Selenium siamo:
- Vai su
http://demo.guru99.com/test/guru99home/ - Leggi tutti i link dei corsi uno per uno
- Stampa il collegamento ipertestuale di tutti i corsi sulla console.
Guru99AntClass.java:
package testAnt;
import java.util.List;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.annotations.Test;
public class Guru99AntClass {
@Test
public void Guru99AntTestNGMethod(){
WebDriver driver = new FirefoxDriver();
driver.get("http://demo.guru99.com/test/guru99home/");
List<WebElement> listAllCourseLinks = driver.findElements(By.xpath("//div[@class='canvas-middle']//a"));
for(WebElement webElement : listAllCourseLinks) {
System.out.println(webElement.getAttribute("href"));
}
}
}
Passo 5) Dopo l'esecuzione riuscita, l'output sarà simile a:
Scarica il file di esempio sopra
Sommario
Ant è uno strumento di creazione per Java.
Formica utilizzata per la compilazione, la distribuzione e il processo di esecuzione del codice.
Ant può essere scaricato da Apache di LPI.
File Build.xml utilizzato per configurare le destinazioni di esecuzione utilizzando Ant.
Ant può essere eseguito dalla riga di comando o tramite un plugin IDE idoneo, come Eclipse.
