Apache ANT avec Selenium: Tutoriel complet
Krishna Rungta
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).
Avantage de la construction Ant
- 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.
- 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.
- Une application complète est créée pour la livraison et le déploiement de bout en bout.
- 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.
- 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
Étape 2) Décompressez le dossier, accédez à et copiez le chemin vers la racine du dossier décompressé.
É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.
Étape 4) Une nouvelle fenêtre s'ouvre. Cliquez sur le bouton « Variable d'environnement… ».
É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.
Étape 6) sélectionnez maintenant la variable « Chemin » dans la liste, cliquez sur « Modifier » et ajoutez ; %ANT_HOME%\bin.
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
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"/>
- Target balises 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 depuis Eclipse, accédez au fichier build.xml -> cliquez avec le bouton droit sur le fichier -> Exécuter en tant que… -> cliquez sur Créer le fichier
Exemple
Nous prendrons un petit exemple de programme qui expliquera très clairement la fonctionnalité Ant. La structure de notre projet ressemblera à –
Ici, dans cet exemple, nous avons 4 cibles
- Définir le chemin de classe pour les fichiers jar externes,
- Nettoyer le code précédemment respecté
- Compiler le code Java existant
- 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>
Comment exécuter TestNG code utilisant Ant
Ici, nous allons créer une classe avec Tester méthodes et définir le chemin de classe pour Contrôle de qualité 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 Target dans Build.xml pour exécuter ceci TestNG code
<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
Téléchargez le fichier ci-dessus
Fourmi avec Selenium Pilote Web
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.
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:
- Cliquez sur
http://demo.guru99.com/test/guru99home/ - Lire tous les liens des cours un par un
- 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 à :
Téléchargez le fichier d'exemple ci-dessus
Résumé
Ant est un outil de construction 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.
