Articles

Cum să integrați Jenkins & Maven cu Selenium?

On septembrie 23, 2021 by

Acest articol face parte din hub-ul nostru de conținut. Pentru resurse mai aprofundate, consultați hub-ul nostru de conținut privind Jenkins Tutorial.

Jenkins este unul dintre instrumentele populare pentru integrarea continuă, gestionarea construcției și testarea automatizării. Maven este un instrument popular de automatizare a construcției care este utilizat pe scară largă pentru proiectele Java. Combinația dintre Selenium, Maven, integrarea Jenkins este culmea integrării și implementării continue.

Ca parte a testării de automatizare, suntem siguri că echipa dvs. vine cu numeroase scripturi de automatizare a testelor Selenium în fiecare zi. Deoarece Selenium în sine nu este utilizat pentru integrarea continuă, Selenium, Maven și integrarea Jenkins sunt valorificate pentru gestionarea construcției și integrarea continuă. În acest articol, analizăm utilizarea lui Maven și Jenkins cu Selenium.

Un scurt rezumat al articolului de blog este mai jos:

Overview Of Selenium, Maven, & Jenkins

Maven este un instrument popular de automatizare a construcției care este utilizat în principal pentru proiectele Java. Avantajul utilizării Maven este că bibliotecile și plugin-urile Java sunt descărcate în mod dinamic din Maven 2 Central Repository.

Dependențele și alte informații esențiale legate de compilare sunt stocate într-un fișier pom.xml al proiectului. Odată descărcate, dependențele sunt stocate într-o memorie cache locală (.M2 repository), iar aceasta este utilizată pentru generarea construcției. Acest lucru simplifică procesul de construire, deoarece orice dependență nouă a proiectului trebuie adăugată doar în pom.xml, adică nu este necesară descărcarea manuală și instalarea pachetelor.

Selenium este un cadru de automatizare a testelor utilizat pe scară largă pentru validarea aplicațiilor web în diferite combinații de browsere, platforme și dispozitive (sau emulatoare). Puteți consulta blogurile noastre despre modul în care Selenium Grid poate fi utilizat pentru testarea automată a browserului.

Jenkins este un instrument CI/CD open-source care ajută la automatizarea activităților legate de compilare, testare și implementare. Jenkins are un ecosistem extins de plugin-uri, este open-source și are o comunitate pasionată – factori care pot fi atribuiți caracteristicilor lui Jenkins.

În acest blog Maven și Jenkins cu Selenium, vom folosi TestNG, care este un cadru de testare popular care este inspirat de JUnit. Este utilizat pe scară largă pentru domenii de testare, cum ar fi testarea funcțională, testarea end-to-end și multe altele.

Aceste sunt setul de instrumente pe care le vom folosi în cadrul demonstrației:

  • Maven – Instrument de gestionare a proiectelor în Java
  • TestNG – Cadru popular de automatizare a testelor
  • Selenium WebDriver – Bibliotecă utilizată în principal pentru automatizarea interacțiunilor din browser
  • Jenkins – Instrument pentru Integrare continuă (CI) și Implementare continuă (CD)

Iată fluxul general de informații atunci când Selenium, Maven și Jenkins sunt integrate:

  • După ce dezvoltatorul împinge codul în depozit (de ex.g., GitHub), se declanșează o construcție Jenkins.
  • Maven descarcă pachetele de biblioteci dependente & și începe să efectueze construcția. Informațiile legate de suita de teste sunt disponibile în testing.xml, iar aceleași informații sunt utilizate și în pom.xml.
  • Se stabilește un obiectiv de construire (de exemplu, install) pentru rularea testelor automate. Același lucru se realizează prin intermediul maven-surefire-plugin.
  • Maven-surefire-plugin îi spune lui TestNG să ruleze testele care se află sub adnotarea @Test.
  • În funcție de AUT (aplicația testată) și de browserul (& combinație de sisteme de operare) pe care se efectuează testele cross browser, Selenium WebDriver invocă instanța de browser corespunzătoare și execută aceleași teste de automatizare.
  • Rezultatele testelor sunt publicate în rapoarte HTML, deoarece pluginul HTML Publisher este utilizat pentru generarea rapoartelor.
  • Chiar dacă un singur caz de test a eșuat, testul complet este marcat cu statusul ‘Failed’.’

Avantajele utilizării Maven & Jenkins cu Selenium

Înainte de a demonstra utilizarea integrării Selenium Maven Jenkins cu Selenium, vom arunca o privire asupra principalelor avantaje ale utilizării Maven și Jenkins cu Selenium:

  • De fiecare dată când se face o modificare în implementare, modificările sunt implementate în mediul de testare. Testarea de automatizare se realizează în mod continuu, iar dezvoltatorii sunt informați cu privire la rezultatele etapei de construire și testare.
  • Succesele de testare care cuprind multe scenarii de testare (sau combinații de testare) ar putea dura mai mult timp pentru testarea de automatizare. În astfel de cazuri, se poate programa o execuție nocturnă pentru compilare și execuție pe serverul Jenkins.
  • Pentru că Maven utilizează pom.xml, se reduce dependența generală de descărcarea manuală a fișierelor jar. De asemenea, tipul „Maven Project” din Jenkins ajută la inițierea integrării Selenium Maven, Jenkins cu câteva setări de configurare.
  • Configurarea integrării Selenium Maven Jenkins este potrivită pentru echipele de dezvoltare și testare distribuite în diferite locații geografice.

Precondiții prealabile pentru proiectul Jenkins Selenium

Pentru demonstrarea Maven și Jenkins cu Selenium, următoarele softuri ar trebui să fie instalate (sau disponibile) pe mașina de pe care se declanșează testele:

  • Eclipse IDE sau IntelliJ IDEA (Maven vine implicit în aceste două IDE-uri)
  • Jenkins în .war format
  • Chrome WebDriver care se potrivește cu versiunea browserului Chrome de pe mașina dumneavoastră
  • Microsoft Edge Driver
  • Account pe LambdaTest (deoarece testele sunt executate pe LambdaTest’s cloud-based Selenium Grid)

Demonstrarea integrării Selenium Maven Jenkins

Pentru a economisi timp, nu vom analiza fiecare etapă de creare a unui proiect Maven. În cazul în care doriți o recapitulare rapidă a Maven cu Selenium, puteți consulta acest tutorial Maven pentru automatizarea testelor Selenium. Pașii utilizați pentru crearea unui proiect Maven în IntelliJ IDEA sunt similari cu cei utilizați pentru crearea unui proiect Maven în Eclipse IDE.

Test Suite – 1

Test Scenario – 1 (Chrome on Windows 10)

  1. Navigați la acest URL- https://lambdatest.github.io/sample-todo-app/.
  2. Alegeți primele două căsuțe de selectare.
  3. Scrieți „Happy Testing at LambdaTest” în caseta de text de mai jos cu următorul id = sampletodotext.
  4. Acum, faceți clic pe butonul Add și verificați dacă textul a fost adăugat sau nu.

Scenariu de testare – 2 (Teste pe 4 combinații diferite de browsere și sisteme de operare)

  1. Navigați la acest URL- https://www.google.com.
  2. Cercetați „LambdaTest”.
  3. Click pe primul rezultat al testului.
  4. Acum, ridicați un Assert dacă titlul paginii nu se potrivește cu titlul așteptat.

Implementare

Dependențele și plugin-urile corespunzătoare trebuie să fie adăugate în pom.xml al proiectului. Iată pachetele cheie (sau jars) care fac parte din pom.xml:

  • Selenium 4 (Alpha)
  • Cadrul TestNG (versiunea 6.9.10)
  • Plugin Maven Surefire pentru execuția suitei de teste care face parte din testng.xml
  • Maven Surefire Report plugin pentru generarea raportului cu rezultatele testelor într-un format HTML

Dacă intenționați să adăugați un nou plugin sau jar la pomul de mai sus.xml, căutați-l în Maven Repository și adăugați dependența/plugin-ul corespunzător în secțiunea relevantă.

Suita de testare conține două cazuri de testare, și anume test_Selenium4_ToDoApp() & test_Selenium4_GoogleSearch(). După cum se arată mai jos, implementarea acestor cazuri de testare este stocată în fișiere separate, și anume CrossBrowserTest.java și GoogleSearchTest.java, iar ambele fac parte din pachetul org.selenium4.

Scenariul de testare test_Selenium4_ToDoApp() este menit să fie executat pe Chrome (ultima versiune) pentru Windows 10. Pe de altă parte, scenariul de testare test_Selenium4_GoogleSearch() trebuie să fie executat pe 4 combinații diferite de browsere și sisteme de operare, și anume Chrome (cea mai recentă) pe Windows 10, Edge (84.0) pe Windows 10, Chrome (cea mai recentă) pe macOS Mojave și Firefox (cea mai recentă) pe OS X Mavericks.

Entrările din testng.xml pentru test_Selenium4_GoogleSearch() au fost aliniate în funcție de capacitățile browserului generate de generatorul de capacități LambdaTest. Mai jos sunt prezentate exemplele de capabilități generate pentru Chrome (cele mai recente) & Combinația Windows 10:

În implementare, vom utiliza ascultătorii TestNG în Selenium WebDriver pentru testarea automată. La nivelul suitei, definim nume de clase pentru a implementa ascultătorii în fișierul xml TestNG. Adnotarea @listeners din TestNG este utilizată pentru adăugarea clasei org.selenium4.GoogleSearchTest.

Cum se arată mai jos, numele testului „Google Search Test – 1” va lua parametrii de intrare care specifică browserul, versiunea, platforma și rezoluția de afișare. Aceste valori vor fi transmise metodei de testare ca argumente prin utilizarea adnotărilor parametrizate (de exemplu, @org.testng.annotations.Parameters(value={„browser”, „version”, „platform”, „resolution”}).

1
2
3
4
5
6
7
8
9
10
11
12
13
<ascultători>

<clasa ascultătorilor-name=”org.selenium4.GoogleSearchTest”/>
</listeners>
<test name=”Test de căutare Google – 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 (Implementarea scenariului de test – 1)

GoogleSearchTest.java (Implementarea scenariului de testare – 2)

Code Walkthrough

Pasul 1 – Pachetele necesare sunt importate înainte de începerea implementării propriu-zise. Deoarece cadrul TestNG este utilizat pentru testare; prin urmare, pachetele sale sunt, de asemenea, importate înainte ca adnotările sale să poată fi utilizate.

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.Assert.*;
import org.junit.Test.*;

Pasul 2 – IExecutionListener este utilizat pentru monitorizarea începutului și sfârșitului suitei de testare, deoarece scenariul de testare ar fi executat pe diferite combinații de intrare care sunt trecute prin fișierul xml TestNG.

The IExecutionListener conține două metode – onExecutionStart() și onExecutionFinish(). onExecutionStart() este invocată înainte de începerea testului, iar onExecutionFinish() este invocată după ce testele/suită de teste au terminat execuția.

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

Pasul 3 – Metoda implementată sub adnotarea @BeforeTest va fi executată înainte de a fi executată orice metodă de testare aparținând clasei aflate sub acea etichetă. Deoarece folosim testarea parametrizată cu TestNG, la metoda de testare se adaugă adnotarea @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”;
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 {
…………………………
…………………………
}

Acești parametri ar fi trecuți valorile din testng.xml, exemplul de parametru prezentat mai jos:

Etapa 4 – Metoda testSetUp este o metodă parametrizată care preia iterativ parametrii de test de la TestNG.xml până când se întâlnește sfârșitul suitei de teste.

Pentru că testele sunt executate în norul Selenium Grid pe LambdaTest, credențialele constau dintr-un nume de utilizator & un token de acces care poate fi folosit pentru a accesa 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”);

Applicația RemoteWebDrive utilizează URL-ul la distanță și capabilitățile browserului care sunt generate cu ajutorul generatorului de capabilități LambdaTest și transmise metodei sub formă de parametri de intrare.

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

Etapa 5 – Metoda de testare este implementată sub adnotarea @Test. Metodele Selenium corespunzătoare (findElement, sendKeys, submit și altele) sunt utilizate pentru a localiza elementul web și pentru a efectua acțiunile corespunzătoare asupra acestuia.

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 {
/* Introduceți termenul de căutare în caseta de căutare Google */
search_box = driver.findElement(By.xpath(„//input”)));
search_box.sendKeys(search_string);
search_box.submit();
……………………………………
……………………………………
}
……………………………………
……………………………………
}

Pasul 6 – Blocarea întârzierilor nu este o bună practică de programare, dar am adăugat câteva întârzieri pentru observarea ieșirii.

1
2
3
4
5
6
7
WebElement lt_link = driver.findElement(By.xpath(„//h3”));
lt_link.click();
/* Nu este o bună practică de programare, adăugată pentru demonstrație */
Thread.sleep(5000);
……………………………………
……………………………………

Pasul 7 – Metoda care este implementată sub adnotarea @AfterTest eliberează resursele alocate de către WebDriver-ul corespunzător instanțiat.

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

Suită de teste – 2

Scenariu de test – 1 (Chrome pe Windows 10)

  1. Navigați la URL-ul https://lambdatest.com
  2. Verificați pagina Title
  3. Comparați titlul paginii cu titlul așteptat
  4. Assertați dacă titlurile nu se potrivesc

Implementare

Este același cu cel care este folosit pentru Test Suite-1, cu excepția lui artifactId și groupID.

CrossBrowserTest.java

Pentru demonstrația Maven și Jenkins cu Selenium, vom executa aceste două suite de teste în paralel, folosind proiectul FreeStyle și Jenkins Pipeline.

Woo-hoo! Vă mulțumim că v-ați înscris la newsletter-ul săptămânal LambdaTest!

Setting Up Jenkins For The Jenkins Selenium Project

Înainte de a crea un nou job în Jenkins care să construiască proiectul menționat mai devreme, trebuie să configurăm mediul Jenkins.

Pasul 1: Calea de instalare a JDK trebuie adăugată la variabila System Environment. Acest lucru este necesar și pentru JRE (Java Runtime Environment).

Pasul 2: Descărcați Jenkins în format .war și porniți Jenkins prin executarea următoarei comenzi pe terminal:

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

În loc de 8080 (numărul de port implicit folosit de Jenkins), pornim serviciul Jenkins pe portul 9090.

Pasul 3: Vizitați localhost:9090 în browserul web pentru a începe să utilizați Jenkins.

Creăm un nou utilizator (cu privilegii de administrator). Conectați-vă folosind acest nume de utilizator pentru a continua să utilizați Jenkins.

Pasul 4: Deoarece proiectul utilizează Maven și Jenkins cu Selenium, setările globale și căile de acces pentru Java & Maven trebuie să fie configurate în Jenkins. Pentru configurarea acestor setări, navigați la „Configure System” (Configurare sistem) în secțiunea „System Configuration” (Configurare sistem).

În elementul intitulat ‘Global properties’ (Proprietăți globale), adăugați următoarele variabile de mediu:

1
2
JAVA_HOME – <Locația în care este instalat JDK>
MAVEN_HOME – <Locația în care este instalat Maven>

În cazul nostru, intrările sunt cele de mai jos:

1
2
JAVA_HOME – C:\\Program Files\Java\jdk1.8.0_251
MAVEN_HOME – C:\\apache-maven\apache-maven-3.6.3\

Click pe Apply and Save.

Adăugarea acestor variabile de mediu în System Configuration face ca setările să fie publice (i.e. pot fi utilizate pentru proiectul Jenkins FreeStyle și proiectul Jenkins Pipeline).

Pasul 5: Plugin-ul HTML Publisher trebuie instalat înainte de a se putea efectua acțiunea post-construcție pentru teste. Același lucru se poate face navigând la „Manage Plugins” (Gestionare pluginuri) și căutând „HTML Publisher Plugin” în fila „Available” (Disponibil). Faceți clic pe „Install” (Instalare) pentru instalarea plugin-ului.

Nota: Pentru testele între browsere, se recomandă utilizarea Jenkins în format .war, deoarece testele sunt executate în modul non-headless (fără cap) numai atunci când Jenkins este utilizat în format .war.

Selenium Maven Jenkins Integration Using FreeStyle Project

Pentru a crea un proiect FreeStyle care utilizează integrarea Selenium Maven Jenkins ca demonstrație, efectuați următorii pași pe Jenkins UI (i.e. localhost:9090/)

(Notă – Numărul portului va varia în funcție de portul utilizat de Jenkins)

Pasul 1: În „Jenkins UI”, faceți clic pe „New Item” (Element nou).

Pasul 2: Introduceți numele sarcinii ca „LambdaTest – Selenium Maven Jenkins integration (Maven Project)” și selectați proiectul „FreeStyle”.

Jenkins oferă, de asemenea, o opțiune pentru a crea un proiect ‘Maven’ în care setările de configurare necesare pentru configurarea proiectului sunt minime. Cu toate acestea, pentru această demonstrație, am folosit un proiect ‘FreeStyle’.

Pasul 3: Mergeți la ‘Build’ ? ‘Invoke top-level Maven targets’. Versiunea Maven trebuie să indice versiunea de Maven instalată pe mașină. În cazul nostru, este Maven 3.6.3.

Pasul 4: Faceți clic pe ‘Advanced’ (Avansat) pentru a seta obiectivele, stabiliți locația fișierelor POM pentru cele două suite de testare. În cazul nostru, locațiile proiectului sunt mai jos:

Dacă dorim să realizăm compilări paralele, folosim următoarea opțiune cu comanda mvn:

1
mvn -T 4 clean install

Această comandă va efectua compilări cu 4 fire. În secțiunea ‘Goals’, trebuie să introduceți -T 4 clean install. Același obiectiv este setat pentru compilările Maven pentru ambele proiecte. În ‘POM’, indicați locația absolută a pom.xml

(de exemplu, Build 1 – C:\Users\Lenovo\IdeaProjects\Maven_Jenkins\pom.xml

Build 2 – C:\Users\Lenovo\IdeaProjects\Maven_Jenkins_2\pom.xml)

Pasul 5: „Acțiunea post-Build” este de a publica rapoarte HTML care oferă informații despre scenariul general de testare (adică numărul de teste trecute/nereușite/saltate, etc.). Selectați ‘Publish HTML Reports’ în ‘Add post-build action’.

Etapa 6: Plugin-ul Maven Surefire Report analizează fișierele TEST-*.xml generate în ${project_dir}/target/surefire-reports și le redă folosind DOXIA. În „HTML directory to archive”, introduceți calea absolută a locației care conține rapoartele Surefire.

Pentru suita de teste 1:

1
2
3
Director HTML pentru arhivare – ${project_dir_1}/target/surefire-reports
Pagina(e) de index – index.html
Titlul raportului – Test Scenario 1 Report

Pentru suita de teste 2:

1
2
3
Director HTML pentru arhivare – ${project_dir_2}/target/surefire-reports
Index Page(s) – index.html
Titlul raportului – Test Scenario 2 Report

Pasul 7: Proiectul este acum gata de compilare. Faceți clic pe opțiunea „Build Now” (Construiește acum) pentru a declanșa construirea.

Etapa 8: Faceți clic pe „Console Output” (Ieșire consolă) pentru a fi martori la progresul etapelor de construire, testare și raportare.

Etapa 9: După cum se vede în ‘Console logs; testele sunt executate cu succes – cinci cazuri de testare ca parte a primei suite de testare și un caz de testare ca parte a celei de-a doua suite de testare.

Iată capturi de ecran ale rapoartelor HTML care sunt generate pentru cele două suite de testare de către Plugin-ul HTML Publisher.

Raport pentru scenariul de testare – 1

Raport pentru scenariul de testare – 2

Selenium Maven Jenkins Integration Using Jenkins Pipeline

În această secțiune a demonstrației Maven și Jenkins cu Selenium, vom folosi Pipeline Jenkins care utilizează un limbaj specific domeniului (DSL) pentru realizarea Pipeline as Code.

Definirea unui Pipeline Jenkins este scrisă în mod normal într-un fișier numit Jenkinsfile. Acest fișier ar conține pașii necesari pentru rularea Pipeline-ului Jenkins. Pentru o scurtă recapitulare a Pipeline-ului Jenkins declarativ, puteți consulta acest tutorial Jenkins Pipeline.

Pentru a integra Maven și Selenium cu Jenkins Pipeline, trebuie să efectuați pașii menționați mai jos:

Pasul 1: Creați un element nou intitulat „LambdaTest – Selenium Maven Jenkins integration (Pipeline Project)” de tip „Pipeline”.

Pasul 2: În definiția Pipeline, lipiți conținutul fișierului Jenkinsfile, așa cum se arată mai jos. Faceți clic pe Apply și Save.

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:\\Users\Lenovo\IdeaProjects\\Maven_Jenkins”
PROJECT_DIR_2 = „C:\Users\Lenovo\IdeaProjects\Maven_Jenkins_2”
}
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 ()
} }
}
}
}
}
}
}

Pasul 3: În secțiunea post-construcție, Plugin-ul HTML Publisher este utilizat pentru crearea rapoartelor de testare post-execuție pentru cele două scenarii de testare.

Pipeline Walkthrough

Pasul 1: Această sarcină Jenkins specifică poate fi executată pe orice agent. Secțiunea cu directiva tools conține toate instrumentele care trebuie să fie instalate automat. Acestea se adaugă apoi și la variabila de mediu PATH.

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

În mașina unde vor fi executate testele, sunt instalate JDK 1.8.0_251 și Maven 3.6.3. Pseudonimele maven și jdk indică versiunile Maven și JDK respective.

Pasul 2: Directiva environment este utilizată pentru definirea variabilelor de mediu PROJECT_DIR_1 și PROJECT_DIR_2 care indică locația în care sunt prezente proiectele Java. Aceste variabile de mediu pot fi utilizate pentru toate etapele sau pentru etapele specifice unei etape, deoarece sunt definite în etapa principală „Run Tests”.’

1
2
3
4
5
6
stages {
stage(‘Run Tests’) {
environment {
PROJECT_DIR_1 = „C:\\Users\Lenovo\IdeaProjects\\Maven_Jenkins”
PROJECT_DIR_2 = „C:\Users\Lenovo\IdeaProjects\Maven_Jenkins_2”
}

Pasul 3: Directiva paralelă din Jenkins este utilizată pentru a executa etapele Pipeline în paralel. În cazul nostru, Pipeline-ul Jenkins este format din două etape – Scenariul de testare 1 și Scenariul de testare 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:\\Users\Lenovo\IdeaProjects\\Maven_Jenkins”
PROJECT_DIR_2 = „C:\Users\Lenovo\IdeaProjects\Maven_Jenkins_2”
}
parallel {
stage(‘Test Scenario 1’) {
…………………………………..
…………………………………..
}
stage(‘Test Scenario 2’) {
…………………………………..
…………………………………..
}
}
}
}

Etapa 4: Acțiunile efectuate în ambele etape sunt exact similare, cu excepția faptului că sunt efectuate pe proiecte diferite. Etapa „Test Scenario 1” se execută pe Nodul „Slave_1„, iar etapa „Test Scenario 2” se execută pe Nodul „Slave_2„.

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

În cazul în care intenționați să executați conducta pe orice agent, puteți sări peste utilizarea unui anumit nume de agent în aceste etape. Puteți consulta blogul nostru Ce este Jenkins pentru a înțelege crearea Nodurilor în Jenkins.

În cazul nostru, am creat două Noduri (Slave_1 și Slave_2) și le-am făcut online înainte de a executa testele.

Etapa 5: În următoarea etapă, se declanșează construirea. Comanda mvn clean install este apoi executată pe pom.xml care este prezent în directorul proiectului. Noi folosim o mașină Windows pentru execuție, prin urmare am folosit comanda bat (sau batch) pentru declanșarea compilării Maven.

1
2
3
4
pași {
echo ‘maven clean’
bat ‘ mvn -f %PROJECT_DIR_1%\\pom.xml clean install’
}

Pasul 6: Acțiunea post-build este utilizată pentru publicarea rapoartelor HTML pentru etapele respective. Acțiunile sunt adăugate sub directiva „post”. Dorim să invocăm crearea raportului de testare numai dacă compilarea are succes. Prin urmare, acțiunile se află sub directiva „success”.

După cum s-a văzut în demonstrația care utilizează proiectul FreeStyle, reportDir este setat la locația în care sunt generate rapoartele surefire (adică ${project_dir}/target/surefire-reports). Câmpul reportFiles este setat la index.html (de exemplu, ${project_dir}/target/surefire-reports/index.html).

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

După ce Pipeline-ul este adăugat la Jenkinsfile, faceți clic pe „Build Now” (Construiește acum) pentru a începe procesul de construire.

Puteți să treceți peste orice etapă și să faceți clic pe „Logs” (Jurnale) pentru a arunca o privire asupra progresului de execuție a etapei respective. După cum se vede din imaginea instantanee a etapei, cele două etape sunt executate în paralel.

Pentru că folosim etape paralele cu Pipeline declarativ în Jenkins, cazurile de testare respective sunt executate în paralel pe grila Selenium bazată pe cloud pe LambdaTest. După cum se arată mai jos, planul nostru pe LambdaTest acceptă maxim cinci teste care să fie executate în paralel.

După cum se arată mai jos, testele s-au executat cu succes.

Timpurile totale de execuție au fost de aproximativ 6 minute. Puteți trece peste orice etapă pentru a vizualiza jurnalele asociate cu acea etapă.

După cum se vede în jurnalele trunchiate, este evident că etapele din cele două stadii se executau în paralel:

Iată captura de ecran a rapoartelor HTML care sunt generate ca parte a acțiunii post-construcție:

Încheiere

sursă

Executarea testelor Selenium în Jenkins oferă flexibilitatea de a executa teste de fiecare dată când există o modificare a software-ului, iar aceste modificări trebuie testate pe diferite combinații de intrare. Maven este utilizat în proiectele Java, deoarece ușurează sarcina de gestionare a dependențelor prin intermediul fișierului pom.xml.

Proiectele de tip liber în Jenkins ar trebui să fie utilizate pentru proiectele care nu sunt de o complexitate ridicată. Pipeline din Jenkins ar trebui să fie utilizat atunci când doriți să definiți Pipeline-ul de implementare sub formă de cod. Directiva paralelă din Jenkins Pipeline ar trebui utilizată pentru a valorifica execuția paralelă a etapelor în Jenkins. Jenkins Pipeline poate fi integrat cu un Grid Selenium bazat pe cloud, cum ar fi LambdaTest, care vă permite, de asemenea, să integrați Maven și Jenkins cu Selenium într-un mod mai eficient.

Sperăm că, urmând acest tutorial, veți integra cu ușurință Maven și Jenkins cu Selenium. Vă mulțumim că ați citit!

Himanshu Sheth

Cu o experiență de peste 7 ani în automatizarea testelor, BDD, TDD, Himanshu Sheth lucrează ca inginer de automatizare cu LambdaTest. El este, de asemenea, un blogger avid.

Scris de

.

Lasă un răspuns

Adresa ta de email nu va fi publicată.