Apache ANT mit Selenium: Vollständiges Tutorial
Krishna Runta
Was ist Apache Ant?
Beim Erstellen eines vollständigen Softwareprodukts muss man sich um verschiedene APIs von Drittanbietern, deren Klassenpfade, das Bereinigen früherer ausführbarer Binärdateien, das Kompilieren unseres Quellcodes, die Ausführung des Quellcodes, die Erstellung von Berichten und die Bereitstellungscodebasis usw. kümmern Wenn Sie die Schritte einzeln manuell durchführen, wird dies enorm viel Zeit in Anspruch nehmen und der Prozess ist fehleranfällig.
Hier zeigt sich die Bedeutung eines Build-Tools wie Ant. Es speichert, führt und automatisiert alle Prozesse in einer sequenziellen Reihenfolge, die in der Konfigurationsdatei von Ant (normalerweise build.xml) angegeben ist.
Vorteil des Ant-Builds
- Ant erstellt den Anwendungslebenszyklus, d. h. Bereinigen, Kompilieren, Festlegen von Abhängigkeiten, Ausführen, Berichten usw.
- Die API-Abhängigkeit von Drittanbietern kann von Ant festgelegt werden, d. h. der Klassenpfad anderer Jar-Dateien wird von der Ant-Build-Datei festgelegt.
- Es wird eine vollständige Anwendung für die End-to-End-Bereitstellung und -Bereitstellung erstellt.
- Es handelt sich um ein einfaches Build-Tool, bei dem alle Konfigurationen mithilfe einer XML-Datei vorgenommen und über die Befehlszeile ausgeführt werden können.
- Dadurch bleibt Ihr Code sauber, da die Konfiguration von der eigentlichen Anwendungslogik getrennt ist.
So installieren Sie Ant
Schritte zur Installation von Ant Windows ist wie folgt
Schritt 1) Zurück Nach https://ant.apache.org/bindownload.cgi Oder laden Sie die ZIP-Datei herunter von apache-ant-1.9.4-bin.zip
Schritt 2) Entpacken Sie den Ordner und kopieren Sie den Pfad zum Stammverzeichnis des entpackten Ordners
Schritt 3) Gehen Sie zu Start -> Computer -> klicken Sie mit der rechten Maustaste hier, wählen Sie „Eigenschaften“ und klicken Sie dann auf „Erweiterte Systemeinstellungen“.
Schritt 4) Es öffnet sich ein neues Fenster. Klicken Sie auf die Schaltfläche „Umgebungsvariable…“.
Schritt 5) Klicken Sie auf die Schaltfläche „Neu…“, legen Sie den Variablennamen auf „ANT_HOME“ und den Variablenwert als Stammpfad zum entpackten Ordner fest und klicken Sie auf „OK“.
Schritt 6) Wählen Sie nun die Variable „Pfad“ aus der Liste aus und klicken Sie auf „Bearbeiten“ und anhängen; %ANT_HOME%\bin.
Starten Sie das System einmal neu und Sie können das Ant-Build-Tool jetzt verwenden.
Schritt 7) So überprüfen Sie die Version Ihres Ant über die Befehlszeile:
Ant-Version
Build.xml verstehen
Build.xml ist die wichtigste Komponente des Ant-Build-Tools. Für ein Java Im Projekt werden alle Reinigungs-, Einrichtungs-, Kompilierungs- und Bereitstellungsaufgaben in dieser Datei im XML-Format aufgeführt. Wenn wir diese XML-Datei über die Befehlszeile oder ein beliebiges IDE-Plugin ausführen, werden alle in diese Datei geschriebenen Anweisungen nacheinander ausgeführt.
Lassen Sie uns den Code in einem build.XML-Beispiel verstehen
-
Das Projekt-Tag wird verwendet, um einen Projektnamen und ein basedir-Attribut zu erwähnen. Das basedir ist das Stammverzeichnis einer Anwendung
<project name="YTMonetize" basedir=".">
- Eigenschafts-Tags werden als Variablen in der Datei build.XML verwendet, um in weiteren Schritten verwendet zu werden
<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, die als Schritte verwendet werden, die in sequenzieller Reihenfolge ausgeführt werden. Das Attribut „Name“ ist der Name des Ziels. Sie können mehrere Ziele in einer einzigen build.xml haben.
<target name="setClassPath">
- Das Pfad-Tag wird verwendet, um alle Dateien, die sich am gemeinsamen Speicherort befinden, logisch zu bündeln
<path id="classpath_jars">
- Das Pathelement-Tag legt den Pfad zum Stammverzeichnis des gemeinsamen Speicherorts fest, an dem alle Dateien gespeichert sind
<pathelement path="${basedir}/"/> - pathconvert-Tag, das zum Konvertieren der Pfade aller gängigen Dateien innerhalb des Path-Tags in das Klassenpfadformat des Systems verwendet wird
<pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>
- Dateisatz-Tag, das zum Festlegen des Klassenpfads für verschiedene JAR-Dateien von Drittanbietern in unserem Projekt verwendet wird
<fileset dir="${ytoperation.dir}" includes="*.jar"/> - Das Echo-Tag wird zum Drucken von Text auf der Konsole verwendet
<echo message="deleting existing build directory"/>
- Tag löschen löscht Daten aus dem angegebenen Ordner
<delete dir="${build.dir}"/>
- Mit dem mkdir-Tag wird ein neues Verzeichnis erstellt
<mkdir dir="${build.dir}"/>
- javac-Tag, das zum Kompilieren von Java-Quellcode und zum Verschieben von .class-Dateien in einen neuen Ordner verwendet wird
<javac destdir="${build.dir}" srcdir="${src.dir}">
<classpath refid="classpath_jars"/>
</javac>
- Das Jar-Tag erstellt eine JAR-Datei aus .class-Dateien
<jar destfile="${ytoperation.dir}/YTOperation.jar" basedir="${build.dir}">
- Das Manifest-Tag legt Ihre Hauptklasse für die Ausführung fest
<manifest> <attribute name="Main-Class" value="test.Main"/> </manifest>
- Das Attribut „abhängig“ wird verwendet, um ein Ziel von einem anderen Ziel abhängig zu machen
<target name="run" depends="compile">
- Das Java-Tag führt die Hauptfunktion aus dem im Kompilierungszielabschnitt erstellten JAR aus
<java jar="${ytoperation.dir}/YTOperation.jar" fork="true"/>
Führen Sie Ant mit aus Eclipse Plugin
Um Ant von Eclipse aus auszuführen, gehen Sie zur Datei build.xml -> Rechtsklick auf die Datei -> Ausführen als… -> klicken Sie auf Datei erstellen
Beispiel
Wir nehmen ein kleines Beispielprogramm, das die Ant-Funktionalität sehr anschaulich erklärt. Unsere Projektstruktur wird wie folgt aussehen:
Hier in diesem Beispiel haben wir 4 Ziele
- Klassenpfad für externe Gläser festlegen,
- Bereinigen Sie zuvor kompilierten Code
- Kompilieren Sie vorhandenen Java-Code
- Führen Sie den Code aus
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>
Wie man ausführt TestNG Code mit Ant
Hier erstellen wir eine Klasse mit Testng Methoden und legen Sie den Klassenpfad fest Tests in build.xml.
Um nun die Testng-Methode auszuführen, erstellen wir eine weitere testng.xml-Datei und rufen diese Datei aus der Datei build.xml auf.
Schritt 1) Wir schaffen eine "Guru99AntClass.class” im Paket 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();
}
}
Schritt 2) Erstellen Sie ein Ziel, um diese Klasse in Build.xml zu laden
<!-- 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>
Schritt 3) Erstellen Sie 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>
Schritt 4) Erschaffung Target in Build.xml, um dies auszuführen 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>
Schritt 5) Die vollständige 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"/>
<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>
Schritt 6) Ausgang
Laden Sie die obige Datei herunter
Ameise mit Selenium Webtreiber
Bisher haben wir gelernt, dass wir mit ANT alle Jars von Drittanbietern an einem bestimmten Ort im System ablegen und ihren Pfad für unser Projekt festlegen können. Mit dieser Methode legen wir alle Abhängigkeiten unseres Projekts an einem einzigen Ort fest und machen es zuverlässiger für die Kompilierung, Ausführung und Bereitstellung.
Ebenso können wir für unsere Testprojekte mit Selenium die Selenium-Abhängigkeit problemlos in build.xml erwähnen und müssen unserer Anwendung keinen Klassenpfad manuell hinzufügen.
Jetzt können Sie die unten erwähnte herkömmliche Methode zum Festlegen von Klassenpfaden für Projekte ignorieren.
Ejemplo:
Wir werden das vorherige Beispiel modifizieren
Schritt 1) Setzen Sie die Eigenschaft selenium.jars auf Selenium-bezogenes Jar im Ressourcenordner
<property name="selenium.jars" value=".\selenium"/>
Schritt 2) Fügen Sie im Ziel setClassPath die Selenium-Dateien hinzu
<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>
Schritt 3) Komplette 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>
Schritt 4) Ändern Sie nun die zuvor erstellte Klasse. Guru99AntClass.java mit neuem Code.
Hier in diesem Beispiel unsere Schritte mit Selenium sind:
- Zurück Nach https://demo.guru99.com/test/guru99home/
- Lesen Sie alle Kurslinks einzeln durch
- Drucken Sie den Hyperlink „Alle Kurse“ auf der Konsole aus.
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"));
}
}
}
Schritt 5) Nach erfolgreicher Ausführung sieht die Ausgabe so aus:
Laden Sie die obige Beispieldatei herunter
Zusammenfassung
Ant ist ein Build-Tool für Java.
Ant wird für die Codekompilierung, Bereitstellung und Ausführung verwendet.
Ant kann heruntergeladen werden von Apache Webseite.
Build.xml-Datei, die zum Konfigurieren von Ausführungszielen mit Ant verwendet wird.
Ant kann über die Befehlszeile oder ein geeignetes IDE-Plugin wie Eclipse ausgeführt werden.
