Apache ANT cu Selenium: Tutorial complet

Ce este Apache Ant?

În timp ce creați un produs software complet, trebuie să aveți grijă de diferitele API-uri terță parte, calea lor de clasă, curățarea fișierelor binare executabile anterioare, compilarea codului nostru sursă, execuția codului sursă, crearea de rapoarte și baza de cod de implementare etc. Dacă aceste sarcini sunt făcut unul câte unul manual, va dura un timp enorm, iar procesul va fi predispus la erori.

Aici intervine importanța unui instrument de construcție precum Ant. Stochează, execută și automatizează toate procesele într-o ordine secvențială menționată în fișierul de configurare al lui Ant (de obicei build.xml).

Beneficiul Ant build

1. Ant creează ciclul de viață al aplicației, adică curățați, compilați, setați dependența, executați, raportați etc.
2. Dependența API-ului terță parte poate fi setată de Ant, adică calea de clasă a altui fișier Jar este setată de fișierul de compilare Ant.
3. Este creată o aplicație completă pentru livrarea și implementarea End to End.
4. Este un instrument simplu de construcție în care toate configurațiile pot fi făcute folosind fișierul XML și care poate fi executat din linia de comandă.
5. Vă face codul curat, deoarece configurația este separată de logica reală a aplicației.

Cum se instalează Ant

Pași pentru a instala Ant în Windows este după cum urmează

Pas 1) Accesează https://ant.apache.org/bindownload.cgi Sau Descărcați fișierul .zip de la apache-ant-1.9.4-bin.zip

Pas 2) Dezarhivați folderul și accesați și copiați calea la rădăcina folderului dezarhivat

Pas 3) Accesați Start -> Computer -> faceți clic dreapta aici și selectați „Proprietăți”, apoi faceți clic pe Setări avansate de sistem

Pas 4) Se deschide o nouă fereastră. Faceți clic pe butonul „Variabilă de mediu…”.

Pas 5) Faceți clic pe butonul „Nou…” și setați numele variabilei ca „ANT_HOME” și valoarea variabilei ca cale rădăcină către folderul dezarhivat și faceți clic pe OK.

Pas 6) acum selectați variabila „Cale” din listă și faceți clic pe „Editare” și adăugați; %ANT_HOME%\bin.

Reporniți sistemul o dată și sunteți gata să utilizați instrumentul Ant build acum.

Pas 7) Pentru a verifica versiunea Ant folosind linia de comandă:

Ant – versiune

Înțelegerea Build.xml

Build.xml este cea mai importantă componentă a instrumentului Ant build. Pentru o Java proiect, toate sarcinile legate de curățare, configurare, compilare și implementare sunt menționate în acest fișier în format XML. Când executăm acest fișier XML folosind linia de comandă sau orice plugin IDE, toate instrucțiunile scrise în acest fișier vor fi executate în mod secvenţial.

Să înțelegem codul dintr-un exemplu de build.XML

• Eticheta de proiect este folosită pentru a menționa un nume de proiect și un atribut basedir. Basedir este directorul rădăcină al unei aplicații

  <project name="YTMonetize" basedir=".">

• Etichetele de proprietate sunt folosite ca variabile în fișierul build.XML pentru a fi utilizate în pașii ulterioare

<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 etichete utilizate ca pași care se vor executa în ordine secvențială. Atributul nume este numele țintei. Puteți avea mai multe ținte într-un singur build.xml

  <target name="setClassPath">

• eticheta path este folosită pentru a grupa toate fișierele care se află în locația comună

  <path id="classpath_jars">

• Eticheta pathelement va seta calea către rădăcina locației comune în care sunt stocate toate fișierele

  <pathelement path="${basedir}/"/>

• Eticheta pathconvert folosită pentru a converti căile tuturor fișierelor comune din interiorul etichetei cale în formatul classpath al sistemului

  <pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>

• Eticheta set de fișiere folosită pentru a seta classpath pentru diferite jar terțe din proiectul nostru

  <fileset dir="${ytoperation.dir}" includes="*.jar"/>

• Eticheta Echo este folosită pentru a imprima text pe consolă

<echo message="deleting existing build directory"/>

• Ștergeți eticheta va șterge datele din folderul dat

<delete dir="${build.dir}"/>

• Tag-ul mkdir va crea un director nou

	<mkdir dir="${build.dir}"/>

• Eticheta javac folosită pentru a compila codul sursă java și pentru a muta fișierele .class într-un folder nou

        <javac destdir="${build.dir}" srcdir="${src.dir}">
	<classpath refid="classpath_jars"/>
</javac>

• jar tag va crea fișierul jar din fișierele .class

	<jar destfile="${ytoperation.dir}/YTOperation.jar" basedir="${build.dir}">

• Eticheta manifest va seta clasa principală pentru execuție

<manifest>
		<attribute name="Main-Class" value="test.Main"/>
</manifest>

• Atributul „depinde” folosit pentru ca o țintă să depindă de o altă țintă

<target name="run" depends="compile">

• Tag-ul java va executa funcția principală din jarul creat în secțiunea țintă de compilare

<java jar="${ytoperation.dir}/YTOperation.jar" fork="true"/>

Rulați Ant folosind Eclipse conecteaza

Pentru a rula Ant din eclipse, accesați fișierul build.xml -> faceți clic dreapta pe fișier -> Executați ca... -> faceți clic pe Build file

Exemplu

Vom lua un mic exemplu de program care va explica foarte clar funcționalitatea Ant. Structura proiectului nostru va arăta astfel:

Aici, în acest exemplu, avem 4 ținte

1. Setați calea clasei pentru borcanele externe,
2. Curățați codul respectat anterior
3. Compilați codul java existent
4. Rulați codul

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>				

Cum se execută TestNG cod folosind Ant

Aici vom crea o clasă cu Testng metode și setați calea clasei pentru Testarea în build.xml.

Acum, pentru a executa metoda testng, vom crea un alt fișier testng.xml și vom apela acest fișier din fișierul build.xml.

Pas 1) Creăm un „Guru99AntClass.class” in pachet 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();					
	}		
}		

Pasul 2) Creați o țintă pentru a încărca această clasă în 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>

Pas 3) Creați 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>

Pas 4) Crează Target în Build.xml pentru a rula acest lucru TestNG cod

<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>				

Pas 5) Build.xml complet

<?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>

Pas 6) producție

Descărcați fișierul de mai sus

Furnica cu Selenium Webdriver

Până acum, am învățat că folosind ANT putem pune toate borcanele terților într-o anumită locație din sistem și le putem stabili calea pentru proiectul nostru. Folosind această metodă, setăm toate dependențele proiectului nostru într-un singur loc și îl facem mai fiabil pentru compilare, execuție și implementare.

În mod similar, pentru proiectele noastre de testare care utilizează seleniu, putem menționa cu ușurință dependența de seleniu în build.xml și nu este nevoie să adăugăm manual o cale de clasă a acesteia în aplicația noastră.

Deci, acum puteți ignora modul tradițional menționat mai jos de a seta căile de clasă pentru proiect.

Exemplu:

Vom modifica exemplul anterior

Pas 1) Setați proprietatea selenium.jars la borcanul legat de seleniu în folderul de resurse

		<property name="selenium.jars" value=".\selenium"/>

Pas 2) În setClassPath țintă, adăugați fișierele cu seleniu

<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>		

Pas 3) Completează 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>

Pas 4) Acum schimbați clasa creată anterior Guru99AntClass.java cu cod nou.

Iată în acest exemplu pașii noștri folosind Selenium sunt:

1. Accesează https://demo.guru99.com/test/guru99home/
2. Citiți link-urile tuturor cursurilor unul câte unul
3. Imprimați hyperlinkul tuturor cursurilor pe consolă.

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("https://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"));
      	  }
		}
}		

Pas 5) După execuția cu succes, rezultatul va arăta astfel:

Descărcați fișierul exemplu de mai sus

Rezumat

Ant este un instrument de construcție pentru Java.

Ant folosit pentru compilarea codului, implementare, proces de execuție.

Ant poate fi descărcat de pe Apache site-ul web.

Fișierul Build.xml utilizat pentru a configura ținte de execuție folosind Ant.

Ant poate fi rulat din linia de comandă sau din pluginul IDE adecvat, cum ar fi Eclipse.