Articles

Hoe integreer je Jenkins & Maven met Selenium?

On september 23, 2021 by

Dit artikel maakt deel uit van onze Content Hub. Bekijk voor meer diepgaande informatie onze hub over Jenkins Tutorial.

Jenkins is een van de populaire tools voor continue integratie, buildbeheer en geautomatiseerd testen. Maven is een populaire build automation tool die veel wordt gebruikt voor Java-projecten. De combinatie van Selenium, Maven, Jenkins integratie is het toppunt van continue integratie en deployment.

Als onderdeel van automatisering testen, we zijn er zeker van uw team komt met tal van Selenium test automatisering scripts om de andere dag. Omdat Selenium zelf niet wordt gebruikt voor continue integratie, worden Selenium, Maven, en Jenkins integratie gebruikt voor build management en continue integratie. In dit artikel kijken we naar het gebruik van Maven en Jenkins met Selenium.

Een korte samenvatting van de blog post staat hieronder:

Overview Of Selenium, Maven, & Jenkins

Maven is een populaire build automation tool die voornamelijk wordt gebruikt voor Java projecten. Het voordeel van het gebruik van Maven is dat Java bibliotheken en plugins worden gedownload op een dynamische basis van de Maven 2 Central Repository.

De afhankelijkheden en andere essentiële build-gerelateerde informatie worden opgeslagen in een pom.xml bestand van het project. Eenmaal gedownload, worden de dependencies opgeslagen in een lokale cache (.M2 repository), en dezelfde wordt gebruikt voor het bouwen generatie. Dit vereenvoudigt het bouwproces, omdat elke nieuwe projectafhankelijkheid alleen in pom.xml hoeft te worden toegevoegd, d.w.z. er zijn geen handmatige download- en installatiepakketten nodig.

Selenium is een veelgebruikt testautomatiseringsraamwerk voor het valideren van webapplicaties in verschillende combinaties van browsers, platforms en apparaten (of emulators). U kunt verwijzen naar onze blogs over hoe Selenium Grid kan worden gebruikt voor het geautomatiseerd testen van browsers.

Jenkins is een open-source CI/CD-tool dat helpt bij de automatisering van activiteiten met betrekking tot bouwen, testen en implementeren. Jenkins heeft een uitgebreid plugin ecosysteem, is open-source, en een gepassioneerde gemeenschap – factoren die kunnen worden toegeschreven aan de functies van Jenkins.

In deze Maven en Jenkins met Selenium blog, zouden we gebruik maken van TestNG, dat is een populaire test framework dat is geïnspireerd door JUnit. Het wordt veel gebruikt voor het testen van gebieden zoals functioneel testen, end-to-end testen, en nog veel meer.

Dit zijn de tools die we in de demonstratie gaan gebruiken:

  • Maven – Project management tool in Java
  • TestNG – Populaire testautomatisering framework
  • Selenium WebDriver – Bibliotheek voornamelijk gebruikt voor de automatisering van browser interacties
  • Jenkins – Tool voor Continuous Integration (CI) en Continuous Deployment (CD)

Hier is de algemene stroom van informatie wanneer Selenium, Maven, en Jenkins zijn geïntegreerd:

  • Als de ontwikkelaar eenmaal code in de repository heeft geplaatst (bijv.g.,
  • Maven downloadt de afhankelijke & bibliotheken en begint met bouwen. De informatie met betrekking tot de testsuite is beschikbaar in testing.xml, en hetzelfde wordt ook gebruikt in pom.xml.
  • Een build doel (bijv. installeren) voor het uitvoeren van de geautomatiseerde tests is ingesteld. Hetzelfde wordt bereikt door de maven-surefire-plugin.
  • De maven-surefire-plugin vertelt TestNG om de tests uit te voeren die onder de annotatie @Test staan.
  • Afhankelijk van de AUT (applicatie onder test) en de browser (& OS combinatie) waarop cross browser tests worden uitgevoerd, de Selenium WebDriver roept de overeenkomstige browser instantie en voert dezelfde automatiseringstests.
  • Testresultaten worden gepubliceerd in HTML-rapporten, als de HTML Publisher plugin wordt gebruikt voor het genereren van rapporten.
  • Zelfs als een enkele testcase is mislukt, wordt de complete test gemarkeerd met de status ‘Mislukt.

Voordelen van het gebruik van Maven & Jenkins met Selenium

Voordat we het gebruik van Selenium Maven Jenkins integratie demonstreren, zullen we een kijkje nemen op de belangrijkste voordelen van het gebruik van Maven en Jenkins met Selenium:

  • Wanneer er een wijziging wordt aangebracht in de implementatie, worden de wijzigingen uitgerold op de testomgeving. Automatisering testen wordt continu uitgevoerd, en ontwikkelaars worden op de hoogte gehouden van de build en test fase resultaten.
  • Test suites die bestaan uit veel test scenario’s (of test combinaties) kan een langere duur voor automatisering testen. Een nachtelijke build run kan worden gepland voor de bouw en uitvoering op de Jenkins server in dergelijke gevallen.
  • Aangezien Maven pom.xml gebruikt, vermindert het de totale afhankelijkheid van het handmatig downloaden van jar-bestanden. Ook het ‘Maven Project’ type in Jenkins helpt bij het aan de slag met Selenium Maven, Jenkins integratie met een paar configuratie-instellingen.
  • De Selenium Maven Jenkins integratie setup is geschikt voor het ontwikkelen en testen van teams verspreid over verschillende geografische locaties.

Voorwaarden voor Jenkins Selenium Project

Voor demonstratie van Maven en Jenkins met Selenium, moeten de volgende softwares zijn geïnstalleerd (of beschikbaar) op de machine van waaruit tests worden getriggerd:

  • Eclipse IDE of IntelliJ IDEA (Maven wordt standaard geleverd in deze beide IDE’s)
  • Jenkins in .war-formaat
  • Chrome WebDriver die overeenkomt met de versie van de Chrome-browser op uw machine
  • Microsoft Edge Driver
  • Account op LambdaTest (aangezien de tests worden uitgevoerd op LambdaTest’s cloud-gebaseerde Selenium Grid)

Demonstratie van Selenium Maven Jenkins-integratie

Voor tijdbesparende doeleinden, zouden we niet elke stap van het maken van een Maven Project bekijken. In het geval dat je een snelle samenvatting wilt van Maven met Selenium, kun je deze Maven tutorial voor Selenium test automatisering bekijken. De stappen die gebruikt worden voor het maken van een Maven project in IntelliJ IDEA zijn vergelijkbaar met de stappen die gebruikt worden voor het maken van een Maven project in Eclipse IDE.

Test Suite – 1

Test Scenario – 1 (Chrome op Windows 10)

  1. Navigeer naar deze URL- https://lambdatest.github.io/sample-todo-app/.
  2. Kies de eerste twee selectievakjes.
  3. Enter ‘Happy Testing at LambdaTest’ in het tekstvak hieronder met de volgende id = sampletodotext.
  4. Klik nu op de knop Toevoegen en controleer of de tekst is toegevoegd of niet.

Test Scenario – 2 (Tests op 4 verschillende browser en OS combinaties)

  1. Navigeer naar deze URL- https://www.google.com.
  2. Zoek naar “LambdaTest”.
  3. Klik op het eerste test resultaat.
  4. Geef nu een Assert op als de Pagina Titel niet overeenkomt met de verwachte titel.

Implementatie

De juiste afhankelijkheden en plugins moeten worden toegevoegd aan de pom.xml van het project. Hier zijn de belangrijkste pakketten (of jars) die deel uitmaken van pom.xml:

  • Selenium 4 (Alpha)
  • TestNG framework (versie 6.9.10)
  • Maven Surefire plugin voor de uitvoering van de testsuite die deel uitmaakt van testng.xml
  • Maven Surefire Report plugin voor het genereren van het testresultaten rapport in een HTML formaat

Als u van plan bent om een nieuwe plugin of jar toe te voegen aan de bovenstaande pom.xml toe te voegen, zoek dan naar dezelfde op de Maven Repository en voeg de corresponderende dependency/plugin toe in de relevante sectie.

De testsuite bevat twee testgevallen, namelijk test_Selenium4_ToDoApp() & test_Selenium4_GoogleSearch(). Zoals hieronder te zien is, is de implementatie van deze testgevallen opgeslagen in afzonderlijke bestanden, namelijk CrossBrowserTest.java en GoogleSearchTest.java, en beide maken deel uit van het pakket org.selenium4.

Het testscenario test_Selenium4_ToDoApp() is bedoeld om te worden uitgevoerd op Chrome (nieuwste versie) voor Windows 10. Anderzijds moet het testscenario test_Selenium4_GoogleSearch() worden uitgevoerd op 4 verschillende browser- en OS-combinaties, namelijk Chrome (laatste versie) op Windows 10, Edge (84.0) op Windows 10, Chrome (laatste versie) op macOS Mojave en Firefox (laatste versie) op OS X Mavericks.

De items in testng.xml voor test_Selenium4_GoogleSearch() zijn afgestemd op de browsercapaciteiten die door de LambdaTest-capaciteitengenerator zijn gegenereerd. Hieronder ziet u de voorbeeldcapaciteiten die zijn gegenereerd voor de combinatie Chrome (nieuwste) & Windows 10:

In de implementatie zouden we TestNG-luisteraars in Selenium WebDriver gebruiken voor automatiseringstests. Op suite-niveau definiëren we in het TestNG xml-bestand class-namen om luisteraars te implementeren. De @listeners annotatie in TestNG wordt gebruikt voor het toevoegen van class org.selenium4.GoogleSearchTest.

Zoals hieronder getoond, zal de testnaam ‘Google Search Test – 1’ invoerparameters aannemen die browser, versie, platform, en beeldschermresolutie specificeren. Deze waarden zouden als argumenten aan de testmethode worden doorgegeven door gebruik te maken van geparametriseerde annotaties (d.w.z. @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”/>
</luisteraars>
<test name=”Google Search Test – 1″>
<parameter name=”browser” value=”Chrome”/>
<parameter name=”version” value=”latest”/>
<parameter name=”platform” value=”Windows 10″/>
<parameter name=”resolutie” value=”1600×1200″/>
<classes>
<class name=”org.selenium4.GoogleSearchTest”/>
</classes>
</test>

CrossBrowserTest.java (Implementatie van testscenario – 1)

GoogleSearchTest.java (Implementatie van Test Scenario – 2)

Code Walkthrough

Stap 1 – De benodigde pakketten worden geïmporteerd voordat met de eigenlijke implementatie wordt begonnen. Aangezien het TestNG framework wordt gebruikt voor testen, worden ook de bijbehorende packages geïmporteerd voordat de annotaties kunnen worden gebruikt.

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

Stap 2 – De IExecutionListener wordt gebruikt voor het bewaken van het begin en einde van de testsuite, aangezien het testscenario zou worden uitgevoerd op verschillende invoercombinaties die worden doorgegeven via het TestNG xml-bestand.

De IExecutionListener bevat twee methoden – onExecutionStart() en onExecutionFinish(). onExecutionStart() wordt aangeroepen voordat de test begint en onExecutionFinish() wordt aangeroepen zodra de tests/testsuites klaar zijn met uitvoeren.

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

Stap 3 – De methode die is geïmplementeerd onder @BeforeTest annotatie wordt uitgevoerd voordat een testmethode die behoort tot de klasse onder die tag wordt uitgevoerd. Aangezien we gebruik maken van geparametriseerd testen met TestNG, wordt de annotatie @Parameters(value={“browser”, “versie”, “platform”, “resolutie”}) toegevoegd aan de testmethode.

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 = “geslaagd”;
public static String gebruikersnaam = “gebruikersnaam”;
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 {
…………………………
…………………………
}

Deze parameters zouden worden doorgegeven waarden uit testng.xml, voorbeeld parameter hieronder weergegeven:

Step 4 – De methode testSetUp is een geparametriseerde methode die iteratief de testparameters uit TestNG.xml tot het einde van de testsuite wordt aangetroffen.

Als de tests worden uitgevoerd op de Selenium Grid-cloud op LambdaTest, bestaan de referenties uit een gebruikersnaam & een toegangstoken dat kan worden gebruikt om toegang te krijgen tot de 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 versie, String platform, String resolutie) gooit Exception {
DesiredCapabilities capabilities = nieuwe DesiredCapabilities();
capabilities.setCapability(“build”, “Google Zoeken – Maven Parallel Testen met Jenkins Pipeline”);
capabilities.setCapability(“name”, “Google Zoeken – Maven Parallel Testen met Jenkins Pipeline”);
…………………………
…………………………
try {
driver = new RemoteWebDriver(new URL(“http://” + gebruikersnaam + “:” + access_key + “@hub.lambdatest.com/wd/hub”), capabilities);
} catch (MalformedURLException e) {
System.out.println(“Invalid grid URL”);
}
System.out.println(“Gestarte sessie”);

De RemoteWebDrive API maakt gebruik van de externe URL en browsermogelijkheden die worden gegenereerd met de LambdaTest-capaciteitengenerator en aan de methode worden doorgegeven in de vorm van invoerparameters.

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

Step 5 – De testmethode is geïmplementeerd onder de @Test annotatie. De juiste Selenium-methoden (findElement, sendKeys, submit, enzovoort) worden gebruikt om het Web Element te lokaliseren en de juiste acties op hetzelfde uit te voeren.

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 {
/* Voer de zoekterm in de Google Search Box in */
search_box = driver.findElement(By.xpath(“//input”));
search_box.sendKeys(search_string);
search_box.submit();
……………………………………
……………………………………
}
……………………………………
……………………………………
}

Stap 6 – Het blokkeren van vertragingen is geen goede programmeerpraktijk, maar we hebben enkele vertragingen toegevoegd voor het observeren van de uitvoer.

1
2
3
4
5
6
7
WebElement lt_link = driver.findElement(By.xpath(“//h3”));
lt_link.click();
/* Geen goede programmeerpraktijk, toegevoegd ter demonstratie */
Thread.sleep(5000);
……………………………………
……………………………………

Stap 7 – De methode die is geïmplementeerd onder @AfterTest annotatie maakt de bronnen vrij die zijn toegewezen door de geïnstantieerde overeenkomstige WebDriver.

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

Testsuite – 2

Testscenario – 1 (Chrome op Windows 10)

  1. Navigeer naar de URL https://lambdatest.com
  2. Controleer de pagina Titel
  3. Vergelijk de paginatitel met de verwachte titel
  4. Bevestig als de titels niet overeenkomen

Uitvoering

Het is dezelfde als die welke wordt gebruikt voor Testsuite-1, behalve voor de artifactId en groupID.

CrossBrowserTest.java

Voor de demonstratie van Maven en Jenkins met Selenium, zouden we deze twee testsuites parallel uitvoeren met behulp van het FreeStyle-project en de Jenkins Pipeline.

Woo-hoo! Bedankt voor je aanmelding voor de wekelijkse nieuwsbrief van LambdaTest!

Jenkins instellen voor het Jenkins Selenium-project

Voordat we een nieuwe job in Jenkins aanmaken die het eerder genoemde project bouwt, moeten we de Jenkins-omgeving instellen.

Stap 1: Het installatiepad van JDK moet worden toegevoegd aan de Systeemomgevingvariabele. Dit is ook nodig voor JRE (Java Runtime Environment).

Step 2: Download Jenkins in .war-formaat en start Jenkins door het volgende commando uit te voeren op de 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

In plaats van 8080 (het standaard poortnummer dat door Jenkins wordt gebruikt), starten we de Jenkins-service op poort 9090.

Stap 3: Ga naar localhost:9090 in de webbrowser om Jenkins te gaan gebruiken.

Maak een nieuwe gebruiker aan (met beheerdersrechten). Log in met die gebruikersnaam om verder te gaan met Jenkins.

Stap 4: Aangezien het project gebruik maakt van Maven en Jenkins met Selenium, moeten de globale instellingen en paden voor Java & Maven geconfigureerd worden in Jenkins. Ga voor het configureren van deze instellingen naar ‘Systeem configureren’ in het gedeelte ‘Systeemconfiguratie’.

In het onderdeel ‘Globale eigenschappen’ voegt u de volgende omgevingsvariabelen toe:

1
2
JAVA_HOME -. <Locatie waar JDK is geïnstalleerd>
MAVEN_HOME – <Locatie waar Maven is geïnstalleerd>

In ons geval zijn de ingangen zoals hieronder:

1
2
JAVA_HOME – C:ProgrammabestandenJavaJdk1.8.0_251
MAVEN_HOME – C:\apache-maven-maven-3.6.3

Klik op Toepassen en Opslaan.

Het toevoegen van deze omgevingsvariabelen in de Systeemconfiguratie maakt de instellingen openbaar (d.w.z.e. kan worden gebruikt voor Jenkins FreeStyle project en Jenkins Pipeline project).

Stap 5: De HTML Publisher Plugin moet worden geïnstalleerd voordat de post-build actie voor de tests kan worden uitgevoerd. Hetzelfde kan worden gedaan door te navigeren naar ‘Beheer Plugins’ en te zoeken naar ‘HTML Publisher Plugin’ in het tabblad ‘Beschikbaar’. Klik op ‘Install’ om de plugin te installeren.

Note: Voor cross browser testen, is het aanbevolen om Jenkins in het .war formaat te gebruiken aangezien de tests alleen in de non-headless mode worden uitgevoerd wanneer Jenkins in het .war-formaat.

Selenium Maven Jenkins Integration Using FreeStyle Project

Voor het maken van een FreeStyle-project dat Selenium Maven Jenkins-integratie als demonstratie gebruikt, voert u de volgende stappen uit op Jenkins UI (d.w.z.e. localhost:9090/)

(Opmerking – Het poortnummer zal variëren op basis van de poort die door Jenkins wordt gebruikt)

Stap 1: Klik in de ‘Jenkins UI’ op ‘Nieuw item’.

Stap 2: Voer de opdrachtnaam in als ‘LambdaTest – Selenium Maven Jenkins-integratie (Maven-project)’ en selecteer het project ‘FreeStyle’.

Jenkins biedt ook een optie om een ‘Maven’-project te maken waarbij de configuratie-instellingen die nodig zijn voor het opzetten van het project minimaal zijn. Voor deze demonstratie hebben we echter een ‘FreeStyle’-project gebruikt.

Stap 3: Ga naar de ‘Build’ ? Bovenste niveau Maven-doelen oproepen’. De Maven versie moet verwijzen naar de versie van Maven die op de machine is geïnstalleerd. In ons geval is dat Maven 3.6.3.

Stap 4: Klik op ‘Advanced’ om de Goals in te stellen, stel de locatie in van de POM-bestanden voor de twee testsuites. In ons geval zijn de projectlocaties als volgt:

Aangezien we parallelle builds willen uitvoeren, gebruiken we de volgende optie met het mvn commando:

1
mvn -T 4 clean install

Met deze opdracht worden builds met 4 threads uitgevoerd. In de sectie ‘Doelen’ moet je -T 4 clean install invullen. Hetzelfde doel is ingesteld voor de Maven builds voor beide projecten. Geef in ‘POM’ de absolute locatie op van pom.xml

(d.w.z. Build 1 – C:\Users\LenovoIdeaProjects\Maven_Jenkins_pom.xml

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

Stap 5: De ‘post-Build actie’ is het publiceren van HTML rapporten die informatie geven over het totale testscenario (d.w.z. het aantal tests dat geslaagd/gefaald/overgeslagen is, etc.). Selecteer ‘Publish HTML Reports’ in ‘Add post-build action’.

Stap 6: De Maven Surefire Report plugin parseert de gegenereerde TEST-*.xml bestanden onder ${project_dir}/target/surefire-reports en rendert ze met DOXIA. In ‘HTML directory to archive’, vul het absolute pad in van die locatie die surefire rapporten bevat.

Voor testsuite 1:

1
2
3
HTML-directory om te archiveren – ${project_dir_1}/target/surefire-reports
Indexpagina(‘s) – index.html
Titel van het rapport – Test Scenario 1 rapport

Voor Test Suite 2:

1
2
3
HTML-directory om te archiveren – ${project_dir_2}/target/surefire-reports
Indexpagina(‘s) – index.html
Titel van het rapport – Rapport Test Scenario 2

Stap 7: Het project is nu klaar voor bouwen. Klik op de optie ‘Nu bouwen’ om het bouwen te starten.

Stap 8: Klik op de ‘Console-uitvoer’ om de voortgang van de bouw-, test- en rapportagefasen te bekijken.

Stap 9: Zoals te zien is in de ‘Console logs; de tests zijn met succes uitgevoerd – vijf testgevallen als onderdeel van de eerste testsuite en één testgeval als onderdeel van de tweede testsuite.

Hier volgen de screenshots van de HTML-rapporten die voor de twee testsuites door de HTML Publisher Plugin worden gegenereerd.

Rapport voor Test Scenario – 1

Rapport voor Test Scenario – 2

Selenium Maven Jenkins Integratie met behulp van Jenkins Pipeline

In dit gedeelte van de demonstratie van Maven en Jenkins met Selenium, zouden we gebruik maken van de Jenkins Pipeline die Domain Specific Language (DSL) gebruikt voor het realiseren van Pipeline als Code.

De definitie van een Jenkins Pipeline wordt normaal gesproken geschreven in een bestand met de naam Jenkinsfile. Dit bestand zou de stappen bevatten die nodig zijn om de Jenkins Pipeline uit te voeren. Voor een snelle recapitulatie van de declaratieve Jenkins Pipeline, kunt u deze Jenkins Pipeline tutorial bekijken.

Om Maven en Selenium met de Jenkins Pipeline te integreren, moet u de onderstaande stappen uitvoeren:

Stap 1: Maak een nieuw item aan met de naam ‘LambdaTest – Selenium Maven Jenkins integratie (Pipeline Project)’ van het type ‘Pipeline’.

Stap 2: plak in de definitie van de pipeline de inhoud van het Jenkins-bestand zoals hieronder wordt weergegeven. Klik op Toepassen en Opslaan.

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
pijplijn {
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 {
succes {
publishHTML ()
}
}
}
stage(‘Test Scenario 2’) {
agent {
label “Slave_2”
}
steps {
echo ‘maven clean’
bat ‘ mvn -f %PROJECT_DIR_2%\pom.xml clean install’
}
post {
succes {
publishHTML ()
}
}
}
}
}
}
}

Step 3: In de post-build sectie wordt de HTML Publisher Plugin gebruikt voor het maken van de post-executie testrapporten voor de twee testscenario’s.

Pipeline Walkthrough

Step 1: Deze specifieke Jenkins job kan op elke Agent worden uitgevoerd. De sectie met de tools directive bevat alle tools die automatisch geïnstalleerd moeten worden. Deze worden dan ook toegevoegd aan de PATH omgevingsvariabele.

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

Op de machine waarop de tests zullen worden uitgevoerd, zijn JDK 1.8.0_251 en Maven 3.6.3 geïnstalleerd. De alias maven en jdk verwijzen naar de respectievelijke Maven en JDK versies.

Step 2: De environment directive wordt gebruikt voor het definiëren van omgevingsvariabelen PROJECT_DIR_1 en PROJECT_DIR_2 die verwijzen naar de locatie waar Java projecten aanwezig zijn. Deze omgevingsvariabelen kunnen worden gebruikt voor alle stappen of voor stap-specifieke stappen, aangezien ze worden gedefinieerd in de hoofd-stap ‘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”
}

Stap 3: De parallelle richtlijn in Jenkins wordt gebruikt om de stappen van de Pipeline parallel uit te voeren. In ons geval bestaat de Jenkins Pipeline uit twee fasen – Test Scenario 1 en 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:\Users\Lenovo\IdeaProjects\Maven_Jenkins”
PROJECT_DIR_2 = “C:\Users\Lenovo\IdeaProjects\Maven_Jenkins_2”
}
parallel {
stage(‘Test Scenario 1’) {
…………………………………..
…………………………………..
}
stage(‘Testscenario 2’) {
…………………………………..
…………………………………..
}
}
}
}

Stap 4: De acties die in beide fasen worden uitgevoerd, zijn precies gelijk, behalve dat ze op verschillende projecten worden uitgevoerd. Fase ‘Test Scenario 1‘ wordt uitgevoerd op Node ‘Slave_1‘ en Fase ‘Test Scenario 2‘ wordt uitgevoerd op Node ‘Slave_2‘.

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

In het geval dat u van plan bent om de pijplijn op een willekeurige agent uit te voeren, kunt u het gebruik van een bepaalde agentnaam in deze fasen overslaan. U kunt onze blog Wat is Jenkins raadplegen voor meer informatie over het maken van nodes in Jenkins.

In ons geval hebben we twee nodes gemaakt (Slave_1 en Slave_2) en deze online gezet voordat we de tests uitvoerden.

Step 5: In de volgende stap wordt de build gestart. Het commando mvn clean install wordt dan uitgevoerd op pom.xml dat aanwezig is in de project directory. We gebruiken een Windows machine voor de uitvoering, vandaar dat we het bat (of batch) commando hebben gebruikt voor het triggeren van de Maven build.

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

Stap 6: De post-build actie wordt gebruikt voor het publiceren van HTML rapporten voor de respectievelijke stadia. De acties worden toegevoegd onder de ‘post’ directive. We willen de test rapport creatie alleen aanroepen als de build succesvol is. Vandaar dat de acties onder de succes directive staan.

Zoals te zien is in de demonstratie met het FreeStyle project, is reportDir ingesteld op de locatie waar surefire rapporten worden gegenereerd (d.w.z. ${project_dir}/target/surefire-reports). Het veld reportFiles is ingesteld op index.html (d.w.z. ${project_dir}/target/surefire-reportss/index.html).

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

Zodra de pipeline is toegevoegd aan Jenkinsfile, klikt u op ‘Build Now’ om het bouwproces te starten.

U kunt met uw muis over een willekeurige stap gaan en op ‘Logs’ klikken om de voortgang van de uitvoering van die bepaalde stap te bekijken. Zoals te zien is in de momentopname van de stap, worden de twee stappen parallel uitgevoerd.

Omdat we parallelle stappen gebruiken met een declaratieve pijplijn in Jenkins, worden de respectieve testgevallen parallel uitgevoerd op het cloudgebaseerde Selenium-rooster op LambdaTest. Zoals hieronder te zien is, ondersteunt ons plan op LambdaTest maximaal vijf tests die parallel kunnen worden uitgevoerd.

Zoals hieronder te zien is, zijn de tests met succes uitgevoerd.

De totale uitvoeringstijd bedroeg ongeveer 6 minuten. U kunt met de muisaanwijzer op een stap gaan staan om de logboeken van die stap te bekijken.

Zoals te zien is in de ingekorte logboeken, is het duidelijk dat de stappen in de twee fasen parallel werden uitgevoerd:

Hier ziet u een screenshot van de HTML-rapporten die worden gegenereerd als onderdeel van de post-buildactie:

Wrapping up

source

Het uitvoeren van Selenium-tests in Jenkins biedt de flexibiliteit om tests uit te voeren telkens als er een softwarewijziging is, en die wijzigingen moeten worden getest tegen verschillende invoercombinaties. Maven wordt gebruikt in Java projecten, omdat het de taak van het beheren van afhankelijkheden via het pom.xml bestand vergemakkelijkt.

Freestyle projecten in Jenkins moeten worden gebruikt voor projecten die niet van hoge complexiteit zijn. Jenkins Pipeline moet worden gebruikt wanneer u de deployment Pipeline als code wilt definiëren. De parallelle richtlijn in Jenkins Pipeline moet worden gebruikt om gebruik te maken van de parallelle uitvoering van Stages in Jenkins. Jenkins Pipeline kan worden geïntegreerd met een cloud-gebaseerd Selenium Grid zoals LambdaTest, waarmee je ook Maven en Jenkins op een efficiëntere manier kunt integreren met Selenium.

We hopen dat u door het volgen van deze tutorial, Maven en Jenkins eenvoudig kunt integreren met Selenium. Bedankt voor het lezen!

Himanshu Sheth

Met 7+ jaar ervaring in testautomatisering, BDD, TDD, werkt Himanshu Sheth als een automatiseringsingenieur bij LambdaTest. Hij is ook een fervent blogger.

Geschreven door

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd.