Articles

Jak zintegrować Jenkinsa i Mavena z Selenium?

On 23 września, 2021 by

Ten artykuł jest częścią naszego Content Hub. Dla bardziej dogłębnych zasobów, sprawdź nasz Content Hub na Jenkins Tutorial.

Jenkins jest jednym z popularnych narzędzi do ciągłej integracji, zarządzania budową i testowania automatyzacji. Maven jest popularnym narzędziem do automatyzacji budowania, które jest szeroko stosowane w projektach Java. Połączenie Selenium, Mavena, integracji Jenkinsa jest szczytem ciągłej integracji i wdrażania.

Jako część testów automatyzacji, jesteśmy pewni, że Twój zespół wymyśla liczne skrypty automatyzacji testów Selenium co drugi dzień. Ponieważ Selenium samo w sobie nie jest używane do ciągłej integracji, Selenium, Maven i integracja Jenkins są wykorzystywane do zarządzania budową i ciągłej integracji. W tym artykule przyjrzymy się wykorzystaniu Mavena i Jenkinsa z Selenium.

Szybkie podsumowanie wpisu na blogu znajduje się poniżej:

Overview Of Selenium, Maven, & Jenkins

Maven jest popularnym narzędziem do automatyzacji budowania, które jest głównie używane do projektów Java. Zaletą używania Mavena jest to, że biblioteki Java i wtyczki są pobierane dynamicznie z Centralnego Repozytorium Maven 2.

Zależności i inne istotne informacje związane z budową są przechowywane w pliku pom.xml projektu. Po pobraniu, zależności są przechowywane w lokalnej pamięci podręcznej (.M2 repozytorium), i to samo jest używane do generowania kompilacji. Upraszcza to proces budowania, ponieważ każda nowa zależność projektu musi być dodana tylko w pom.xml, tj. nie jest wymagane ręczne pobieranie i instalowanie pakietów.

Selenium jest szeroko stosowanym frameworkiem automatyzacji testów do sprawdzania poprawności aplikacji internetowych w różnych kombinacjach przeglądarek, platform i urządzeń (lub emulatorów). Możesz odnieść się do naszych blogów o tym, jak Selenium Grid może być używany do zautomatyzowanego testowania przeglądarki.

Jenkins jest open-source’owym narzędziem CI/CD, które pomaga w automatyzacji działań związanych z budową, testowaniem i wdrażaniem. Jenkins posiada rozległy ekosystem wtyczek, jest open-source i ma pasjonującą społeczność – czynniki, które można przypisać do funkcji Jenkinsa.

W tym blogu Maven i Jenkins z Selenium, będziemy używać TestNG, który jest popularnym frameworkiem testowym, który jest inspirowany przez JUnit. Jest szeroko stosowany do testowania obszarów takich jak testowanie funkcjonalne, testowanie end-to-end i inne.

To jest zestaw narzędzi, których będziemy używać w demonstracji:

  • Maven – Narzędzie do zarządzania projektami w Javie
  • TestNG – Popularny framework do automatyzacji testów
  • Selenium WebDriver – Biblioteka używana głównie do automatyzacji interakcji w przeglądarce
  • Jenkins – Narzędzie do ciągłej integracji (CI) i ciągłego wdrażania (CD)

Tutaj jest ogólny przepływ informacji, gdy Selenium, Maven i Jenkins są zintegrowane:

  • Od momentu, gdy programista wepchnie kod do repozytorium (np.g., GitHub), uruchamiany jest build Jenkinsa.
  • Maven pobiera zależne od bibliotek & pakiety i rozpoczyna wykonywanie builda. Informacje związane z zestawem testów są dostępne w pliku testing.xml, który jest również wykorzystywany w pom.xml.
  • Ustawiany jest cel budowania (np. install) dla uruchomienia testów automatycznych. To samo jest osiągane poprzez maven-surefire-plugin.
  • Maven-surefire-plugin mówi TestNG, aby uruchomił testy, które są pod adnotacją @Test.
  • W zależności od AUT (testowana aplikacja) i przeglądarki (& kombinacja OS), na której wykonywane są testy cross browser, Selenium WebDriver wywołuje odpowiednią instancję przeglądarki i wykonuje te same testy automatyzacji.
  • Wyniki testów są publikowane w raportach HTML, ponieważ wtyczka HTML Publisher jest używana do generowania raportów.
  • Nawet jeśli pojedynczy przypadek testowy zakończył się niepowodzeniem, cały test jest oznaczany statusem 'Failed.

Advantages Of Using Maven & Jenkins With Selenium

Zanim zademonstrujemy użycie integracji Selenium Maven Jenkins, przyjrzymy się głównym zaletom używania Mavena i Jenkinsa z Selenium:

  • Każda zmiana dokonana w implementacji, zmiany są wdrażane na środowisko testowe. Testowanie automatyczne jest wykonywane w sposób ciągły, a programiści są informowani o wynikach etapu budowania i testowania.
  • Zestawy testowe, które składają się z wielu scenariuszy testowych (lub kombinacji testów) mogą wymagać dłuższego czasu na testowanie automatyczne. W takich przypadkach można zaplanować nocny przebieg budowania i wykonywania na serwerze Jenkinsa.
  • Jako że Maven używa pom.xml, zmniejsza ogólną zależność od ręcznego pobierania plików jar. Również typ 'Maven Project’ w Jenkins pomaga w rozpoczęciu pracy z Selenium Maven, integracja Jenkins z kilkoma ustawieniami konfiguracyjnymi.
  • Ustawienie integracji Selenium Maven Jenkins jest odpowiednie dla zespołów rozwijających i testujących rozproszonych w różnych lokalizacjach geograficznych.

Prerequisites For Jenkins Selenium Project

Do demonstracji Mavena i Jenkinsa z Selenium, następujące oprogramowanie powinno być zainstalowane (lub dostępne) na maszynie, z której uruchamiane są testy:

  • Eclipse IDE lub IntelliJ IDEA (Maven jest domyślnie dostarczany w obu tych IDE)
  • Jenkins w formacie .war
  • Chrome WebDriver pasujący do wersji przeglądarki Chrome na twoim komputerze
  • Microsoft Edge Driver
  • Konto w LambdaTest (ponieważ testy są wykonywane w chmurze LambdaTest’s cloud-based Selenium Grid)

Demonstracja integracji Selenium Maven Jenkins

Dla zaoszczędzenia czasu, nie będziemy analizować każdego kroku tworzenia projektu Maven. W przypadku, gdybyś chciał szybko podsumować Maven z Selenium, możesz odnieść się do tego samouczka Maven dla automatyzacji testów Selenium. Kroki używane do tworzenia projektu Maven w IntelliJ IDEA są podobne do tych używanych przy tworzeniu projektu Maven w Eclipse IDE.

Test Suite – 1

Scenariusz testowy – 1 (Chrome na Windows 10)

  1. Navigate to this URL- https://lambdatest.github.io/sample-todo-app/.
  2. Wybierz dwa pierwsze pola wyboru.
  3. Wpisz „Happy Testing at LambdaTest” w polu tekstowym poniżej z następującym id = sampletodotext.
  4. Teraz kliknij na przycisk Dodaj i sprawdź, czy tekst został dodany, czy nie.

Scenariusz testowy – 2 (Testy na 4 różnych przeglądarkach i kombinacjach OS)

  1. Przejdź do tego URL- https://www.google.com.
  2. Wyszukaj „LambdaTest”.
  3. Kliknij na pierwszy wynik testu.
  4. Teraz podnieś Assert, jeśli tytuł strony nie pasuje do oczekiwanego tytułu.

Implementacja

Właściwe zależności i wtyczki muszą zostać dodane w pom.xml projektu. Oto kluczowe pakiety (lub słoiki), które są częścią pom.xml:

  • Selenium 4 (Alpha)
  • Framework TestNG (wersja 6.9.10)
  • Wtyczka Maven Surefire do wykonywania zestawu testów, która jest częścią testng.xml
  • Maven Surefire Report plugin for generating the test results report into an HTML format

Jeśli zamierzasz dodać jakiś nowy plugin lub słoik do powyższego pom.xml, wyszukaj je w Repozytorium Mavena i dodaj odpowiednią zależność/wtyczkę w odpowiedniej sekcji.

Zestaw testów zawiera dwa przypadki testowe, mianowicie test_Selenium4_ToDoApp() & test_Selenium4_GoogleSearch(). Jak pokazano poniżej, implementacja tych przypadków testowych jest przechowywana w oddzielnych plikach, mianowicie CrossBrowserTest.java i GoogleSearchTest.java, i oba są częścią pakietu org.selenium4.

Scenariusz testowy test_Selenium4_ToDoApp() jest przeznaczony do wykonania na Chrome (Najnowsza wersja) dla Windows 10. Z drugiej strony, scenariusz testowy test_Selenium4_GoogleSearch() musi zostać wykonany na 4 różnych kombinacjach przeglądarek i systemów operacyjnych tj. Chrome (najnowszy) na Windows 10, Edge (84.0) na Windows 10, Chrome (najnowszy) na macOS Mojave oraz Firefox (najnowszy) na OS X Mavericks.

Wpisy w testng.xml dla test_Selenium4_GoogleSearch() zostały wyrównane zgodnie z możliwościami przeglądarek wygenerowanymi przez generator możliwości LambdaTest. Poniżej pokazane są przykładowe możliwości wygenerowane dla Chrome (najnowsze) & Kombinacja Windows 10:

W implementacji wykorzystalibyśmy słuchaczy TestNG w Selenium WebDriver do testów automatyzacji. Na poziomie pakietu, definiujemy nazwy klas do implementacji słuchaczy w pliku xml TestNG. Adnotacja @listeners w TestNG jest używana do dodania klasy org.selenium4.GoogleSearchTest.

Jak pokazano poniżej, test o nazwie 'Test Wyszukiwania Google – 1′ będzie pobierał parametry wejściowe określające przeglądarkę, wersję, platformę i rozdzielczość wyświetlania. Wartości te zostaną przekazane do metody testowej jako argumenty przy użyciu sparametryzowanych adnotacji (np. @org.testng.annotations.Parameters(value={„browser”, „version”, „platform”, „resolution”}).

1
2
3
4
5
6
7
8
9
10
11
12
13
<listeners>
<listener class-.name=”org.selenium4.GoogleSearchTest”/>
</listeners>
<test name=”Google Search Test -. 1″>
<parameter name=”browser” value=”Chrome”/>
<parameter name=”version” value=”latest”/>
<parameter name=”platform” value=”Windows 10″/>
<parameter name=”resolution” value=”1600×1200″/>
<classes>
<class name=”org.selenium4.GoogleSearchTest”/>
</classes>
</test>

CrossBrowserTest.java (Implementacja scenariusza testowego – 1)

GoogleSearchTest.java (Implementacja scenariusza testowego – 2)

Code Walkthrough

Krok 1 – Zanim rozpocznie się właściwa implementacja, importowane są niezbędne pakiety. Ponieważ framework TestNG jest używany do testowania; więc jego pakiety są również importowane, zanim jego adnotacje mogą być użyte.

1
2
3
4
5
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import static org.junit.Assert.*;
import org.junit.Test.*;

Krok 2 – IExecutionListener jest używany do monitorowania początku i końca zestawu testów, ponieważ scenariusz testowy byłby wykonywany na różnych kombinacjach wejściowych, które są przekazywane przez plik xml TestNG.

IExecutionListener zawiera dwie metody – onExecutionStart() i onExecutionFinish(). onExecutionStart() jest wywoływana przed rozpoczęciem testu i onExecutionFinish() jest wywoływana po zakończeniu wykonywania testów/zestawów testów.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class GoogleSearchTest implements IExecutionListener {
/* protected static EdgeDriver driver; */
String URL = „https://www.google.com/”;
…………………………..
…………………………..
…………………………..
@Override
public void onExecutionStart() {
System.out.println(„onExecutionStart”);
}
@Override
public void onExecutionFinish() {
System.out.println(„onExecutionFinish”);
}

Krok 3 – Metoda zaimplementowana pod adnotacją @BeforeTest zostanie uruchomiona przed uruchomieniem jakiejkolwiek metody testowej należącej do klasy pod tym znacznikiem. Ponieważ używamy sparametryzowanego testowania z TestNG, do metody testowej dodajemy adnotację @Parameters(value={„browser”, „version”, „platform”, „resolution”}).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class GoogleSearchTest implements IExecutionListener {
/* protected static EdgeDriver driver; */
String URL = „https://www.google.com/”;
String search_string = „LambdaTest”;
WebDriver driver = null;
…………………………
…………………………
public static String status = „passed”;
public static String username = „user-name”;
public static String access_key = „access-key”;
…………………………
…………………………
@BeforeTest
@Parameters(value={„browser”, „version”, „platform”, „resolution”})
public void testSetUp(String browser, String version, String platform, String resolution) throws Exception {
…………………………
…………………………
}

Parametry te byłyby przekazywane wartościami z testng.xml, przykładowy parametr pokazany poniżej:

Krok 4 – Metoda testSetUp jest sparametryzowaną metodą, która iteracyjnie pobiera parametry testu z TestNG.xml aż do napotkania końca zestawu testów.

Jako że testy są wykonywane w chmurze Selenium Grid na LambdaTest, dane uwierzytelniające składają się z nazwy użytkownika & tokena dostępu, który może być użyty do uzyskania dostępu do LambdaTest Grid – @hub.lambdatest.com/wd/hub.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void testSetUp(String browser, String version, String platform, String resolution) throws Exception {
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability(„build”, „Google Search – Maven Parallel Testing with Jenkins Pipeline”);
capabilities.setCapability(„name”, „Google Search – Maven Parallel Testing with Jenkins Pipeline”);
…………………………
…………………………
try {
driver = new RemoteWebDriver(new URL(„http://” + username + „:” + access_key + „@hub.lambdatest.com/wd/hub”), capabilities);
} catch (MalformedURLException e) {
System.out.println(„Invalid grid URL”);
}
System.out.println(„Started session”);

Interpretacja API RemoteWebDrive wykorzystuje zdalny adres URL i możliwości przeglądarki, które są generowane za pomocą generatora możliwości LambdaTest i przekazywane do metody w postaci parametrów wejściowych.

1
2
3
4
try {
driver = new RemoteWebDriver(new URL(„http://” + username + „:” + access_key + „@hub.lambdatest.com/wd/hub”), capabilities);
}
catch (MalformedURLException e)

Krok 5 – Metoda testowa jest zaimplementowana pod adnotacją @Test. Odpowiednie metody Selenium (findElement, sendKeys, submit, i inne) są używane do zlokalizowania elementu sieci Web i wykonania na nim odpowiednich akcji.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Test
public void test_Selenium4_GoogleSearch() throws InterruptedException {
driver.navigate().to(URL);
driver.manage().window().maximize();
try {
/* Wpisz wyszukiwane hasło w polu wyszukiwania Google */
search_box = driver.findElement(By.xpath(„//input”));
search_box.sendKeys(search_string);
search_box.submit();
……………………………………
……………………………………
}
……………………………………
……………………………………
}

Krok 6 – Blokowanie opóźnień nie jest dobrą praktyką programistyczną, ale dodaliśmy kilka opóźnień dla obserwacji wyjścia.

1
2
3
4
5
6
7
WebElement lt_link = driver.findElement(By.xpath(„//h3”));
lt_link.click();
/* Nie jest to dobra praktyka programistyczna, dodana w celach demonstracyjnych */
Thread.sleep(5000);
……………………………………
……………………………………

Krok 7 – Metoda, która jest zaimplementowana w ramach adnotacji @AfterTest zwalnia zasoby zaalokowane przez zainicjowany odpowiedni WebDriver.

1
2
3
4
5
6
7
@AfterClass
public void tearDown() {
if (driver != null) {
((JavascriptExecutor) driver).executeScript(„lambda-status=” + status);
driver.quit();
}
}

Test Suite – 2

Scenariusz testowy – 1 (Chrome na Windows 10)

  1. Nawigacja do URL https://lambdatest.com
  2. Sprawdź stronę Title
  3. Porównaj tytuł strony z oczekiwanym tytułem
  4. Zapewnij, jeśli tytuły nie pasują

Implementacja

Jest taka sama jak ta, która jest używana w Test Suite-.1, z wyjątkiem artifactId i groupID.

CrossBrowserTest.java

Dla demonstracji Mavena i Jenkinsa z Selenium, będziemy wykonywać te dwa zestawy testów równolegle używając projektu FreeStyle i Jenkins Pipeline.

Woo-hoo! Dzięki za zapisanie się do cotygodniowego newslettera LambdaTest!

Setting Up Jenkins For The Jenkins Selenium Project

Przed utworzeniem nowego zadania w Jenkins, które buduje wspomniany wcześniej projekt, musimy skonfigurować środowisko Jenkins.

Krok 1: Ścieżka instalacji JDK musi zostać dodana do Zmiennej Środowiskowej Systemu. Jest to również wymagane dla JRE (Java Runtime Environment).

Krok 2: Pobierz Jenkinsa w formacie .war i uruchom Jenkinsa, wykonując następujące polecenie w terminalu:

1
java -Dhudson.model.DirectoryBrowserSupport.CSP=”sandbox allow-scripts allow-popups allow-popups-to-escape-sandbox; style-src 'unsafe-inline’ *;” -Dsvnkit.http.sslProtocols=TLSv1 -jar Jenkins.war –httpPort=9090

Zamiast 8080 (domyślny numer portu używany przez Jenkinsa), uruchamiamy usługę Jenkinsa na porcie 9090.

Krok 3: Odwiedź localhost:9090 w przeglądarce internetowej, aby rozpocząć korzystanie z usługi Jenkins.

Utwórz nowego użytkownika (z uprawnieniami administratora). Zaloguj się przy użyciu tej nazwy użytkownika, aby kontynuować korzystanie z Jenkins.

Krok 4: Ponieważ projekt używa Maven i Jenkins z Selenium, ustawienia globalne i ścieżki dla Java & Maven muszą być skonfigurowane w Jenkins. Aby skonfigurować te ustawienia, przejdź do 'Configure System’ w sekcji 'System Configuration’.

W pozycji zatytułowanej 'Właściwości globalne’ dodaj następujące zmienne środowiskowe:

1
2
JAVA_HOME -. <Lokalizacja, w której zainstalowany jest JDK>
MAVEN_HOME – <Lokalizacja, w której zainstalowany jest Maven>

W naszym przypadku wpisy są jak poniżej:

1
2
JAVA_HOME – C:\Program Files\Java

MAVEN_HOME – C:\apache-maven\apache-maven-3.6.3\

Kliknij na Zastosuj i Zapisz.

Dodanie tych zmiennych środowiskowych w Konfiguracji systemu powoduje, że ustawienia są publiczne (tj.e. mogą być użyte dla projektu Jenkins FreeStyle i projektu Jenkins Pipeline).

Krok 5: Plugin HTML Publisher powinien być zainstalowany przed wykonaniem akcji post-build dla testów. Można to zrobić poprzez przejście do 'Manage Plugins’ i wyszukanie 'HTML Publisher Plugin’ w zakładce 'Available’. Kliknij na 'Install’, aby zainstalować wtyczkę.

Uwaga: Dla testów między przeglądarkami zaleca się używanie Jenkinsa w formacie .war, ponieważ testy są wykonywane w trybie bez nagłówka tylko wtedy, gdy Jenkins jest używany w formacie .war.

Selenium Maven Jenkins Integration Using FreeStyle Project

Dla utworzenia projektu FreeStyle, który używa integracji Selenium Maven Jenkins jako demonstracji, wykonaj następujące kroki w Jenkins UI (i.localhost:9090/)

(Uwaga – Numer portu będzie się różnił w zależności od portu używanego przez Jenkinsa)

Krok 1: W 'Jenkins UI’, kliknij na 'New Item’.

Krok 2: Wprowadź nazwę zadania jako 'LambdaTest – Selenium Maven Jenkins integration (Maven Project)’ i wybierz projekt 'FreeStyle’.

Jenkins zapewnia również możliwość utworzenia projektu 'Maven’, w którym ustawienia konfiguracyjne wymagane do skonfigurowania projektu są minimalne. Jednak do tej demonstracji użyliśmy projektu 'FreeStyle’.

Krok 3: Przejdź do zakładki 'Build’ ? 'Invoke top-level Maven targets’. Wersja Mavena powinna wskazywać na wersję Mavena zainstalowaną na maszynie. W naszym przypadku jest to Maven 3.6.3.

Krok 4: Kliknij na 'Zaawansowane’, aby ustawić Cele, ustaw lokalizację plików POM dla dwóch zestawów testowych. W naszym przypadku, lokalizacje projektów są następujące:

Jako że chcemy wykonać równoległe budowanie, używamy następującej opcji z poleceniem mvn:

1
mvn -T 4 clean install

To polecenie wykona kompilacje z 4 wątkami. W sekcji 'Goals’ powinieneś wpisać -T 4 clean install. Ten sam cel jest ustawiony dla buildów Mavena dla obu projektów. W 'POM’, podaj absolutną lokalizację pom.xml

(tj. Build 1 – C:\u002600>

Build 2 – C:\u002600>

Build 2 – C:\u002600>

Maven_Jenkins_2\u002600↩.xml)

Krok 5: Akcja 'post-Build’ polega na opublikowaniu raportów HTML, które dają informacje o ogólnym scenariuszu testowym (tj. liczba testów zaliczonych/nieudanych/opuszczonych, itp.) Wybierz 'Publish HTML Reports’ w 'Add post-build action’.

Krok 6: Plugin Maven Surefire Report parsuje wygenerowane pliki TEST-*.xml pod ${project_dir}/target/surefire-reports i renderuje je używając DOXIA. W polu 'HTML directory to archive’ należy podać bezwzględną ścieżkę do lokalizacji zawierającej raporty surefire.

Dla zestawu testów 1:

1
2
3
Katalog HTML do archiwum -. ${project_dir_1}/target/surefire-reports
Strona(y) indeksu – index.html
Tytuł raportu – Test Scenario 1 Report

Dla Test Suite 2:

1
2
3
Katalog HTML do archiwizacji -. ${project_dir_2}/target/surefire-reports
Strona(y) indeksu – index.html
Tytuł raportu – Test Scenario 2 Report

Krok 7: Projekt jest teraz gotowy do budowania. Kliknij na opcję „Buduj teraz”, aby uruchomić budowanie.

Krok 8: Kliknij na „Wyjście konsoli”, aby zobaczyć postęp budowania, testowania i etapy raportowania.

Krok 9: Jak widać w 'Console logs; testy są wykonywane pomyślnie – pięć przypadków testowych jako część pierwszego zestawu testów i jeden przypadek testowy jako część drugiego zestawu testów.

Tutaj są zrzuty ekranu raportów HTML, które są generowane dla dwóch zestawów testów przez HTML Publisher Plugin.

Raport dla scenariusza testowego – 1

Raport dla scenariusza testowego – 2

Selenium Maven Jenkins Integration Using Jenkins Pipeline

W tej części demonstracji Maven i Jenkins z Selenium, będziemy używać Jenkins Pipeline, który używa Domain Specific Language (DSL) do realizacji Pipeline as Code.

Definicja Potoku Jenkinsa jest zwykle zapisywana w pliku o nazwie Jenkinsfile. Ten plik zawierałby kroki niezbędne do uruchomienia potoku Jenkinsa. Aby szybko podsumować deklaratywny Jenkins Pipeline, możesz sprawdzić ten tutorial Jenkins Pipeline.

Aby zintegrować Maven i Selenium z Jenkins Pipeline, musisz wykonać kroki wymienione poniżej:

Krok 1: Utwórz nowy element zatytułowany „LambdaTest – Selenium Maven Jenkins integration (Pipeline Project)” typu „Pipeline”.

Krok 2: W definicji Pipeline, wklej zawartość Jenkinsfile jak pokazano poniżej. Kliknij na Zastosuj i Zapisz.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
pipeline {
agent any
tools {
maven 'MAVEN_3.6.3′
jdk 'JDK_1.8.0_251′
}
stages {
stage(’Run Tests’) {
environment {
PROJECT_DIR_1 = „C:
PROJECT_DIR_2 = „C:
PROJECT_DIR_2 = „C:
}
parallel {
stage(’Test Scenario 1′) {
agent {
label „Slave_1”
}
steps {
echo 'maven clean’
bat ’ mvn -f %PROJECT_DIR_1%Pom.xml clean install’
}
post {
success {
publishHTML ()
}
}
}
stage(’Test Scenario 2′) {
agent {
label „Slave_2”
}
steps {
echo 'maven clean’
bat ’ mvn -f %PROJECT_DIR_2%Pom.xml clean install’
}
post {
success {
publishHTML ()
}
}
}
}
}
}
}

Krok 3: W sekcji post-build wtyczka HTML Publisher Plugin jest używana do tworzenia raportów testowych po wykonaniu dla dwóch scenariuszy testowych.

Pipeline Walkthrough

Krok 1: To konkretne zadanie Jenkinsa można uruchomić na dowolnym agencie. Sekcja z dyrektywą tools zawiera wszystkie narzędzia, które muszą być zainstalowane automatycznie. Te same są następnie dodawane do zmiennej środowiskowej PATH.

1
2
3
4
5
6
pipeline {
agent any
tools {
maven 'MAVEN_3.6.3′
jdk 'JDK_1.8.0_251′
}

Na maszynie, na której będą wykonywane testy, zainstalowane są JDK 1.8.0_251 i Maven 3.6.3. Alias maven i jdk wskazują na odpowiednie wersje Mavena i JDK.

Krok 2: Dyrektywa environment służy do zdefiniowania zmiennych środowiskowych PROJECT_DIR_1 i PROJECT_DIR_2, które wskazują na lokalizację, w której znajdują się projekty Java. Te zmienne środowiskowe mogą być używane dla wszystkich kroków lub dla kroków specyficznych dla danego etapu, ponieważ są one zdefiniowane w głównym etapie 'Run Tests.’

1
2
3
4
5
6
stages {
stage(’Run Tests’) {
environment {
PROJECT_DIR_1 = „C:
PROJECT_DIR_2 = „C:
PROJECT_DIR_2 = „C:
}

Krok 3: Dyrektywa parallel w Jenkinsie służy do równoległego wykonywania etapów Pipeline. W naszym przypadku Pipeline Jenkinsa składa się z dwóch etapów – Test Scenario 1 i Test Scenario 2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
stages {
stage(’Run Tests’) {
environment {
PROJECT_DIR_1 = „C:
PROJECT_DIR_2 = „C:
PROJECT_DIR_2 = „C:
}
parallel {
stage(’Test Scenario 1′) {
…………………………………..
…………………………………..
}
stage(’Scenariusz testowy 2′) {
…………………………………..
…………………………………..
}
}
}
}

Krok 4: Czynności wykonywane w obu etapach są dokładnie podobne, z wyjątkiem tego, że są wykonywane na różnych projektach. Etap ’Test Scenario 1’ jest wykonywany na węźle ’Slave_1’, a etap ’Test Scenario 2’ jest wykonywany na węźle ’Slave_2’.

1
2
3
4
5
6
7
8
9
10
11
parallel {
stage(’Test Scenario 1′) {
agent {
label „Slave_1”
}
………….
………….
stage(’Test Scenario 2′) {
agent {
label „Slave_2”
}

W przypadku, gdy zamierzasz wykonać potok na dowolnym agencie, możesz pominąć użycie konkretnej nazwy agenta w tych etapach. Możesz odnieść się do naszego bloga Czym jest Jenkins, aby zrozumieć tworzenie węzłów w Jenkins.

W naszym przypadku utworzyliśmy dwa węzły (Slave_1 i Slave_2) i uczyniliśmy je online przed uruchomieniem testów.

Krok 5: W następnym kroku uruchamiany jest build. Polecenie mvn clean install jest następnie wykonywane na pliku pom.xml, który znajduje się w katalogu projektu. Używamy maszyny z systemem Windows do wykonania, stąd użyliśmy polecenia bat (lub batch) do uruchomienia budowania Mavena.

1
2
3
4
steps {
echo 'maven clean’
bat ’ mvn -.f %PROJECT_DIR_1%Pom.xml clean install’
}

Krok 6: Akcja post-build jest używana do publikowania raportów HTML dla poszczególnych etapów. Akcje są dodawane pod dyrektywą 'post’. Chcemy wywołać tworzenie raportu testowego tylko wtedy, gdy budowanie zakończy się sukcesem. Dlatego też, akcje znajdują się pod dyrektywą success.

Jak widać w demonstracji przy użyciu projektu FreeStyle, reportDir jest ustawiony na lokalizację, w której generowane są raporty surefire (tj. ${project_dir}/target/surefire-reports). Pole reportFiles jest ustawione na index.html (np. ${project_dir}/target/surefire-reports/index.html).

1
2
3
4
5
6
7
8
9
10
11
12
13
post {
success {
publishHTML ()
}
}

Po dodaniu Pipeline do Jenkinsfile, kliknij na 'Build Now’, aby rozpocząć proces budowania.

Możesz najechać na dowolny Etap i kliknąć na 'Logs’, aby spojrzeć na postęp wykonania tego konkretnego Etapu. Jak widać na zrzucie etapu, dwa etapy są wykonywane równolegle.

Jako że używamy etapów równoległych z deklaratywnym Pipeline w Jenkinsie, odpowiednie przypadki testowe są wykonywane równolegle na opartej na chmurze siatce Selenium na LambdaTest. Jak widać poniżej, nasz plan na LambdaTest obsługuje maksymalnie pięć testów do wykonania równolegle.

Jak widać poniżej, testy zostały wykonane pomyślnie.

Całkowity czas wykonania wyniósł około 6 minut. Możesz najechać kursorem na dowolny etap, aby wyświetlić logi związane z tym etapem.

Jak widać w okrojonych logach, jest oczywiste, że kroki w dwóch etapach były wykonywane równolegle:

Tutaj znajduje się zrzut ekranu raportów HTML, które są generowane jako część akcji post-build:

Wrapping up

source

Running Selenium tests in Jenkins gives the flexibility to run tests each time there is a software change, and those changes have to be tested against different input combinations. Maven jest używany w projektach Java, ponieważ ułatwia zadanie zarządzania zależnościami poprzez plik pom.xml.

Projekty Freestyle w Jenkinsie powinny być używane dla projektów, które nie mają dużej złożoności. Jenkins Pipeline powinien być używany, gdy chcesz zdefiniować deployment Pipeline jako kod. Dyrektywa parallel w Jenkins Pipeline powinna być używana, aby wykorzystać równoległe wykonywanie etapów w Jenkinsie. Jenkins Pipeline może być zintegrowany z opartym na chmurze Selenium Grid, takim jak LambdaTest, który pozwala również zintegrować Mavena i Jenkinsa z Selenium w bardziej efektywny sposób.

Mamy nadzieję, że podążając za tym tutorialem, łatwo zintegrujesz Mavena i Jenkinsa z Selenium. Dziękujemy za przeczytanie!

Himanshu Sheth

Z ponad 7-letnim doświadczeniem w automatyzacji testów, BDD, TDD, Himanshu Sheth pracuje jako inżynier automatyzacji w LambdaTest. Jest również zapalonym blogerem.

Written by

.

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany.