Apache ANT z Selenium: Kompletny samouczek
Krishna Szczebel
Co to jest Apache Ant?
Tworząc kompletne oprogramowanie, należy zadbać o różne API stron trzecich, ich ścieżkę klas, czyszczenie poprzednich wykonywalnych plików binarnych, kompilację naszego kodu źródłowego, wykonanie kodu źródłowego, tworzenie raportów i bazy kodu wdrożeniowego itp. Jeśli te zadania są wykonywane pojedynczo ręcznie, zajmie to mnóstwo czasu, a proces będzie podatny na błędy.
Tutaj pojawia się znaczenie narzędzia do kompilacji, takiego jak Ant. Przechowuje, wykonuje i automatyzuje wszystkie procesy w kolejności określonej w pliku konfiguracyjnym Anta (zwykle build.xml).
Korzyści z kompilacji Ant
- Ant tworzy cykl życia aplikacji, tj. czyszczenie, kompilacja, ustawianie zależności, uruchamianie, raportowanie itp.
- Zależność API strony trzeciej może zostać ustawiona przez Ant, tzn. ścieżka klas innego pliku Jar jest ustawiana przez plik kompilacji Ant.
- Tworzona jest kompletna aplikacja umożliwiająca kompleksową dostawę i wdrożenie.
- Jest to proste narzędzie do budowania, w którym wszystkie konfiguracje można wykonać przy użyciu pliku XML i które można uruchomić z wiersza poleceń.
- Dzięki temu Twój kod będzie czysty, ponieważ konfiguracja jest oddzielona od rzeczywistej logiki aplikacji.
Jak zainstalować Anta
Kroki, aby zainstalować Anta Windows następująco
Krok 1) Iść do https://ant.apache.org/bindownload.cgi Lub Pobierz plik .zip z Apache-ant-1.9.4-bin.zip
Krok 2) Rozpakuj folder, przejdź do katalogu głównego rozpakowanego folderu i skopiuj go
Krok 3) Przejdź do Start -> Komputer -> kliknij tutaj prawym przyciskiem myszy i wybierz „Właściwości”, a następnie kliknij Zaawansowane ustawienia systemu
Krok 4) Otworzy się nowe okno. Kliknij przycisk „Zmienna środowiskowa…”.
Krok 5) Kliknij przycisk „Nowy…” i ustaw nazwę zmiennej na „ANT_HOME”, a wartość zmiennej jako ścieżkę główną do rozpakowanego folderu i kliknij OK.
Krok 6) teraz wybierz z listy zmienną „Ścieżka”, kliknij „Edytuj” i dołącz; %ANT_HOME%\bin.
Uruchom ponownie system raz i będziesz gotowy do użycia narzędzia do budowania Ant.
Krok 7) Aby sprawdzić wersję Anta za pomocą wiersza poleceń:
Mrówka – wersja
Zrozumienie pliku Build.xml
Build.xml jest najważniejszym komponentem narzędzia do budowania Anta. Dla Java projektu, wszystkie zadania związane z czyszczeniem, konfiguracją, kompilacją i wdrażaniem są wymienione w tym pliku w formacie XML. Kiedy wykonamy ten plik XML za pomocą wiersza poleceń lub dowolnej wtyczki IDE, wszystkie instrukcje zapisane w tym pliku zostaną wykonane sekwencyjnie.
Przyjrzyjmy się kodowi w przykładowej kompilacji.XML
-
Znacznik projektu służy do podania nazwy projektu i atrybutu Basedir. Basedir to katalog główny aplikacji
<project name="YTMonetize" basedir=".">
- Tagi właściwości są używane jako zmienne w pliku build.XML do wykorzystania w dalszych krokach
<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 tagi używane jako kroki, które będą wykonywane w kolejności sekwencyjnej. Atrybut nazwy to nazwa celu. Możesz mieć wiele celów w jednym pliku build.xml
<target name="setClassPath">
- Znacznik ścieżki służy do logicznego łączenia wszystkich plików znajdujących się we wspólnej lokalizacji
<path id="classpath_jars">
- tag pathelement ustawi ścieżkę do katalogu głównego wspólnej lokalizacji, w której przechowywane są wszystkie pliki
<pathelement path="${basedir}/"/> - tag pathconvert używany do konwersji ścieżek wszystkich popularnych plików znajdujących się wewnątrz znacznika path na systemowy format ścieżki klas
<pathconvert pathsep=";" property="test.classpath" refid="classpath_jars"/>
- znacznik zestawu plików używany do ustawiania ścieżki klasy dla innego słoika strony trzeciej w naszym projekcie
<fileset dir="${ytoperation.dir}" includes="*.jar"/> - Znacznik Echo służy do drukowania tekstu na konsoli
<echo message="deleting existing build directory"/>
- Usuń tag wyczyści dane z podanego folderu
<delete dir="${build.dir}"/>
- znacznik mkdir utworzy nowy katalog
<mkdir dir="${build.dir}"/>
- znacznik javac używany do kompilowania kodu źródłowego Java i przenoszenia plików .class do nowego folderu
<javac destdir="${build.dir}" srcdir="${src.dir}">
<classpath refid="classpath_jars"/>
</javac>
- znacznik jar utworzy plik jar z plików .class
<jar destfile="${ytoperation.dir}/YTOperation.jar" basedir="${build.dir}">
- manifest tag ustawi twoją główną klasę do wykonania
<manifest> <attribute name="Main-Class" value="test.Main"/> </manifest>
- Atrybut „zależy” używany do uzależnienia jednego celu od innego celu
<target name="run" depends="compile">
- znacznik Java wykona główną funkcję ze słoika utworzonego w sekcji docelowej kompilacji
<java jar="${ytoperation.dir}/YTOperation.jar" fork="true"/>
Uruchom Anta za pomocą Eclipse wtyczka
Aby uruchomić Ant z poziomu Eclipse, przejdź do pliku build.xml -> kliknij prawym przyciskiem myszy na pliku -> Uruchom jako… -> kliknij Kompiluj plik
Przykład
Weźmiemy mały przykładowy program, który bardzo jasno wyjaśni funkcjonalność Anta. Struktura naszego projektu będzie wyglądać następująco:
W tym przykładzie mamy 4 cele
- Ustaw ścieżkę klas dla zewnętrznych słoików,
- Wyczyść wcześniej zastosowany kod
- Skompiluj istniejący kod Java
- Uruchom kod
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();
}
}
Kompilacja.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>
Jak wykonać TestNG kod za pomocą Anta
Tutaj utworzymy klasę z Testowanie metody i ustaw ścieżkę klasy dla Testowanie w pliku build.xml.
Teraz, aby wykonać metodę testng, utworzymy kolejny plik testng.xml i wywołamy go z pliku build.xml.
Krok 1) Tworzymy „Guru99AntClass.class” w pakiecie 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();
}
}
Krok 2) Utwórz cel, aby załadować tę klasę w 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>
Krok 3) Utwórz 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>
Krok 4) Stwórz Target w Build.xml, aby to uruchomić TestNG kod
<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>
Krok 5) Kompletny plik 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>
Krok 6) Wydajność
Mrówka z Selenium Sterownik internetowy
Do tej pory dowiedzieliśmy się, że za pomocą ANT możemy umieścić wszystkie słoiki innych firm w określonej lokalizacji w systemie i wyznaczyć ich ścieżkę dla naszego projektu. Korzystając z tej metody, ustawiamy wszystkie zależności naszego projektu w jednym miejscu i zwiększamy jego niezawodność podczas kompilacji, wykonywania i wdrażania.
Podobnie w naszych projektach testowych wykorzystujących Selenium możemy łatwo wspomnieć o zależności Selenium w pliku build.xml i nie musimy ręcznie dodawać ścieżki klas do naszej aplikacji.
Więc teraz możesz zignorować wymieniony poniżej tradycyjny sposób ustawiania ścieżek klas dla projektu.
Przykład:
Zmodyfikujemy poprzedni przykład
Krok 1) Ustaw właściwość selenium.jars na plik jar związany z selenium w folderze zasobów
<property name="selenium.jars" value=".\selenium"/>
Krok 2) W ścieżce docelowej setClassPath dodaj pliki selenu
<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>
Krok 3) Kompletny plik 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>
Krok 4) Zmień teraz utworzoną wcześniej klasę Guru99AntClass.java na nowy kod.
Tutaj, w tym przykładzie, nasze kroki przy użyciu Selenium należą:
- Iść do
http://demo.guru99.com/test/guru99home/ - Przeczytaj linki do wszystkich kursów jeden po drugim
- Wydrukuj hiperłącze do wszystkich kursów na konsoli.
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"));
}
}
}
Krok 5) Po pomyślnym wykonaniu dane wyjściowe będą wyglądać następująco:
Pobierz powyższy przykładowy plik
Podsumowanie
Ant to narzędzie do budowania Java.
Mrówka używana do kompilacji kodu, wdrażania, procesu wykonywania.
Ant można pobrać z Apache stronie internetowej.
Plik Build.xml używany do konfigurowania celów wykonania przy użyciu Anta.
Ant można uruchomić z wiersza poleceń lub za pomocą odpowiedniej wtyczki IDE, np. Eclipse.
