Apache ANT avec Selenium : Tutoriel complet

Qu’est-ce qu’Apache Ant ?

Lors de la création d'un produit logiciel complet, il faut s'occuper des différentes API tierces, de leur chemin de classe, du nettoyage des fichiers binaires exécutables précédents, de la compilation de notre code source, de l'exécution du code source, de la création de rapports et de la base de code de déploiement, etc. Si ces tâches sont effectué un par un manuellement, cela prendra énormément de temps et le processus sera sujet à des erreurs.

Voici l'importance d'un outil de construction comme Ant. Il stocke, exécute et automatise tous les processus dans un ordre séquentiel mentionné dans le fichier de configuration d'Ant (généralement build.xml).

Fourmi Apache

Avantage de la construction Ant

  1. Ant crée le cycle de vie de l'application, c'est-à-dire nettoyer, compiler, définir les dépendances, exécuter, créer un rapport, etc.
  2. La dépendance à l'API tierce peut être définie par Ant, c'est-à-dire que le chemin de classe d'un autre fichier Jar est défini par le fichier de construction Ant.
  3. Une application complète est créée pour la livraison et le déploiement de bout en bout.
  4. Il s'agit d'un outil de construction simple où toutes les configurations peuvent être effectuées à l'aide d'un fichier XML et qui peut être exécuté à partir de la ligne de commande.
  5. Cela rend votre code propre car la configuration est distincte de la logique réelle de l'application.

Comment installer Ant

Étapes pour installer Ant dans Windows est comme suit

Étape 1) Cliquez sur https://ant.apache.org/bindownload.cgi Ou téléchargez le fichier .zip depuis apache-ant-1.9.4-bin.zip

Installer Ant

Étape 2) Décompressez le dossier, accédez à et copiez le chemin vers la racine du dossier décompressé.

Installer Ant

Étape 3) Allez dans Démarrer -> Ordinateur -> faites un clic droit ici et sélectionnez « Propriétés », puis cliquez sur Paramètres système avancés.

Installer Ant

Étape 4) Une nouvelle fenêtre s'ouvre. Cliquez sur le bouton « Variable d'environnement… ».

Installer Ant

Étape 5) Cliquez sur le bouton « Nouveau… » et définissez le nom de la variable sur « ANT_HOME » et la valeur de la variable comme chemin racine du dossier décompressé, puis cliquez sur OK.

Installer Ant

Étape 6) sélectionnez maintenant la variable « Chemin » dans la liste, cliquez sur « Modifier » et ajoutez ; %ANT_HOME%\bin.

Installer Ant

Redémarrez le système une fois et vous êtes maintenant prêt à utiliser l'outil de construction Ant.

Étape 7) Pour vérifier la version de votre Ant en utilisant la ligne de commande :

Version fourmi

Installer Ant

Comprendre Build.xml

Build.xml est le composant le plus important de l'outil de construction Ant. Pour un Java projet, toutes les tâches liées au nettoyage, à l'installation, à la compilation et au déploiement sont mentionnées dans ce fichier au format XML. Lorsque nous exécutons ce fichier XML à l'aide de la ligne de commande ou de n'importe quel plugin IDE, toutes les instructions écrites dans ce fichier seront exécutées de manière séquentielle.

Comprenons le code dans un exemple de build.XML

  • La balise Project est utilisée pour mentionner un nom de projet et un attribut basedir. Le basedir est le répertoire racine d'une application
    <project name="YTMonetize" basedir=".">
  • Les balises de propriété sont utilisées comme variables dans le fichier build.XML à utiliser dans les étapes suivantes
<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"/>
  • Balises cibles utilisées comme étapes qui s’exécuteront dans un ordre séquentiel. L'attribut Name est le nom de la cible. Vous pouvez avoir plusieurs cibles dans un seul build.xml
    <target name="setClassPath">
  • La balise de chemin est utilisée pour regrouper logiquement tous les fichiers qui se trouvent à l'emplacement commun
    <path id="classpath_jars">
  • La balise pathelement définira le chemin d'accès à la racine de l'emplacement commun où tous les fichiers sont stockés
    <pathelement path="${basedir}/"/>
  • balise pathconvert utilisée pour convertir les chemins de tous les fichiers courants à l'intérieur de la balise de chemin au format de chemin de classe du système
    <pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>
  • balise fileset utilisée pour définir le chemin de classe pour différents fichiers jar tiers dans notre projet
    <fileset dir="${ytoperation.dir}" includes="*.jar"/>
  • La balise Echo est utilisée pour imprimer du texte sur la console
<echo message="deleting existing build directory"/>
  • La balise Supprimer nettoiera les données du dossier donné
<delete dir="${build.dir}"/>
  • La balise mkdir créera un nouveau répertoire
	<mkdir dir="${build.dir}"/>
  • balise javac utilisée pour compiler le code source Java et déplacer les fichiers .class vers un nouveau dossier
        <javac destdir="${build.dir}" srcdir="${src.dir}">
	<classpath refid="classpath_jars"/>
</javac>
  • La balise jar créera un fichier jar à partir de fichiers .class
	<jar destfile="${ytoperation.dir}/YTOperation.jar" basedir="${build.dir}">
  • La balise manifest définira votre classe principale pour l'exécution
<manifest>
		<attribute name="Main-Class" value="test.Main"/>
</manifest>
  • attribut 'depends' utilisé pour faire dépendre une cible d'une autre cible
<target name="run" depends="compile">
  • La balise java exécutera la fonction principale à partir du pot créé dans la section cible de compilation
<java jar="${ytoperation.dir}/YTOperation.jar" fork="true"/>

Exécutez Ant en utilisant Eclipse plug-in

Pour exécuter Ant à partir de eclipse allez dans le fichier build.xml -> faites un clic droit sur le fichier -> Exécuter en tant que… -> cliquez sur Créer le fichier

Exécutez Ant en utilisant Eclipse Brancher

Exemple

Nous prendrons un petit exemple de programme qui expliquera très clairement la fonctionnalité Ant. La structure de notre projet ressemblera à –

Exécutez Ant en utilisant Eclipse Brancher

Ici, dans cet exemple, nous avons 4 cibles

  1. Définir le chemin de classe pour les fichiers jar externes,
  2. Nettoyer le code précédemment respecté
  3. Compiler le code Java existant
  4. Exécutez le code

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();					  
	}		
}

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

Exécutez Ant en utilisant Eclipse plug-in

Comment exécuter du code TestNG à l'aide de Ant

Exécuter le code TestNG à l'aide de Ant

Ici, nous allons créer une classe avec Tester méthodes et définir le chemin de classe pour Essais dans build.xml.

Maintenant, pour exécuter la méthode testng, nous allons créer un autre fichier testng.xml et appeler ce fichier à partir du fichier build.xml.

Étape 1) Nous créons un « Guru99AntClass.class » en paquet 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();					
	}		
}		

Étape 2) Créez une cible pour charger cette classe dans 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>

Étape 3) Créer 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>

Étape 4) Créez une cible dans Build.xml pour exécuter ce code TestNG

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

Étape 5) Le 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>

Étape 6) Sortie

Exécuter le code TestNG à l'aide de Ant

Téléchargez le fichier ci-dessus

Fourmi avec Selenium Webdriver

Jusqu'à présent, nous avons appris qu'en utilisant ANT, nous pouvons placer tous les fichiers jar tiers à un emplacement particulier du système et définir leur chemin pour notre projet. En utilisant cette méthode, nous définissons toutes les dépendances de notre projet en un seul endroit et le rendons plus fiable pour la compilation, l'exécution et le déploiement.

De même, pour nos projets de test utilisant le sélénium, nous pouvons facilement mentionner la dépendance au sélénium dans build.xml et nous n'avons pas besoin d'en ajouter manuellement un chemin de classe dans notre application.

Alors maintenant, vous pouvez ignorer la méthode traditionnelle mentionnée ci-dessous pour définir les chemins de classe pour le projet.

Fourmi avec Selenium Webdriver

Mise en situation :

Nous allons modifier l'exemple précédent

Étape 1) Définissez la propriété selenium.jars sur le pot lié au sélénium dans le dossier de ressources

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

Étape 2) Dans le setClassPath cible, ajoutez les fichiers 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>		

Étape 3) Complétez le fichier 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>

Étape 4) Modifiez maintenant la classe Guru99AntClass.java créée précédemment avec le nouveau code.

Ici, dans cet exemple, nos étapes utilisant Selenium sont :

  1. Cliquez sur http://demo.guru99.com/test/guru99home/
  2. Lire tous les liens des cours un par un
  3. Imprimez le lien hypertexte de tous les cours sur la 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"));
      	  }
		}
}		

Étape 5) Après une exécution réussie, le résultat ressemblera à :

Fourmi avec Selenium Webdriver

Téléchargez le fichier d'exemple ci-dessus

Résumé

Ant est un outil de build pour Java.

Fourmi utilisée pour la compilation de code, le déploiement et le processus d'exécution.

Ant peut être téléchargé depuis Apache en ligne.

Fichier Build.xml utilisé pour configurer les cibles d'exécution à l'aide d'Ant.

Ant peut être exécuté à partir de la ligne de commande ou d'un plugin IDE approprié comme eclipse.