Articles

Hvordan integrerer man Jenkins og Maven med Selenium?

On september 23, 2021 by

Denne artikel er en del af vores Content Hub. For mere dybdegående ressourcer kan du tjekke vores indholdshub om Jenkins Tutorial.

Jenkins er et af de populære værktøjer til kontinuerlig integration, build management og automatiseringstest. Maven er et populært værktøj til automatisering af opbygning, der er meget udbredt til Java-projekter. Kombinationen af Selenium, Maven, Jenkins integration er højdepunktet af kontinuerlig integration og implementering.

Som en del af automatiseringstestning er vi sikre på, at dit team kommer op med adskillige Selenium test automatiseringsskripter hver anden dag. Da Selenium ikke i sig selv bruges til kontinuerlig integration, udnyttes Selenium, Maven og Jenkins integration til build management og kontinuerlig integration. I denne artikel ser vi på brugen af Maven og Jenkins med Selenium.

Et hurtigt resumé af blogindlægget er nedenfor:

Overblik over Selenium, Maven, & Jenkins

Maven er et populært byggeautomatiseringsværktøj, der primært bruges til Java-projekter. Fordelen ved at bruge Maven er, at Java-biblioteker og plugins hentes dynamisk fra Maven 2 Central Repository.

Afhængighederne og andre vigtige build-relaterede oplysninger gemmes i en pom.xml-fil i projektet. Når de er downloadet, gemmes afhængighederne i en lokal cache (.M2-repository), og det samme bruges til build-generering. Dette forenkler byggeprocessen, da enhver ny projektafhængighed kun skal tilføjes i pom.xml, dvs. der kræves ingen manuel downloading og installationspakker.

Selenium er en bredt anvendt ramme for testautomatisering til validering af webapplikationer på tværs af forskellige kombinationer af browsere, platforme og enheder (eller emulatorer). Du kan se vores blogs om, hvordan Selenium Grid kan bruges til automatiseret browsertestning.

Jenkins er et open source CI/CD-værktøj, der hjælper med automatisering af aktiviteter i forbindelse med build, test og deployment. Jenkins har et omfattende plugin-økosystem, er open source og har et passioneret fællesskab – faktorer, der kan tilskrives Jenkins’ funktioner.

I denne Maven og Jenkins med Selenium-blog ville vi bruge TestNG, som er en populær testramme, der er inspireret af JUnit. Det bruges i vid udstrækning til testområder som funktionel testning, end-to-end-testning og meget mere.

Dette er det sæt værktøjer, som vi ville bruge i demonstrationen:

  • Maven – Projektstyringsværktøj i Java
  • TestNG – Populær ramme for testautomatisering
  • Selenium WebDriver – Bibliotek, der primært bruges til automatisering af browserinteraktioner
  • Jenkins – Værktøj til Continuous Integration (CI) og Continuous Deployment (CD)

Her er den overordnede informationsstrøm, når Selenium, Maven og Jenkins er integreret:

    • Når udvikleren skubber kode ind i repositoriet (f.eks.g., GitHub), udløses et Jenkins build.
    • Maven downloader de afhængige biblioteker &pakker og begynder at udføre build’et. Oplysningerne vedrørende testpakken er tilgængelige i testing.xml, og det samme bruges også i pom.xml.
    • Et build-mål (f.eks. install) for at køre de automatiserede tests er angivet. Det samme opnås gennem maven-surefire-plugin.
    • Maven-surefire-plugin fortæller TestNG at køre de tests, der er under annotationen @Test.
    • Afhængigt af AUT’en (applikation under test) og browseren (& OS-kombination), som testene på tværs af browserne udføres på, påkalder Selenium WebDriver den tilsvarende browserinstans og udfører de samme automatiseringstest.
    • Testresultaterne offentliggøres i HTML-rapporter, da HTML Publisher-plugin’et bruges til rapportgenerering.
    • Selv om en enkelt testcase er mislykkedes, markeres den komplette test med status ‘Mislykkedes’.’

    Fordele ved at bruge Maven & Jenkins med Selenium

    Hvor vi demonstrerer brugen af Selenium Maven Jenkins-integration, vil vi tage et kig på de vigtigste fordele ved at bruge Maven og Jenkins med Selenium:

    • Hver gang der foretages en ændring i implementationen, udrulles ændringerne på testmiljøet. Automatiseringstest udføres løbende, og udviklerne holdes informeret om resultaterne af build- og testfasen.
    • Testsuiter, der omfatter mange testscenarier (eller testkombinationer), kan tage længere tid for automatiseringstest. En natlig build-kørsel kan planlægges til build og udførelse på Jenkins-serveren i sådanne tilfælde.
    • Da Maven bruger pom.xml, reducerer det den samlede afhængighed af den manuelle download af jar-filer. Desuden hjælper typen ‘Maven Project’ i Jenkins med at komme i gang med Selenium Maven, Jenkins-integration med nogle få konfigurationsindstillinger.
    • Den Selenium Maven Jenkins-integrationsopsætning er velegnet til udviklings- og testteams, der er fordelt på forskellige geografiske steder.

    Forudsætninger for Jenkins Selenium-projekt

    For demonstration af Maven og Jenkins med Selenium skal følgende programmer være installeret (eller tilgængelige) på den maskine, hvorfra testene udløses:

    • Eclipse IDE eller IntelliJ IDEA (Maven kommer som standard i begge disse IDE’er)
    • Jenkins i .war-format
    • Chrome WebDriver, der passer til versionen af Chrome-browseren på din maskine
    • Microsoft Edge Driver
    • Konto på LambdaTest (da testene udføres på LambdaTests cloud-baserede Selenium Grid)

    Demonstration af Selenium Maven Jenkins-integration

    Til tidsbesparende formål, ville vi ikke se nærmere på hvert enkelt trin i oprettelsen af et Maven-projekt. Hvis du gerne vil have en hurtig opsummering af Maven med Selenium, kan du henvise til denne Maven-tutorial til Selenium-testautomatisering. De trin, der bruges til at oprette et Maven-projekt i IntelliJ IDEA, svarer til dem, der bruges til at oprette et Maven-projekt i Eclipse IDE.

    Test Suite – 1

    Test Scenario – 1 (Chrome på Windows 10)

  1. Navigér til denne URL- https://lambdatest.github.io/sample-todo-app/.
  2. Vælg de to første afkrydsningsfelter.
  3. Indtast “Happy Testing at LambdaTest” i tekstboksen nedenfor med følgende id = sampletodotext.
  4. Klik nu på knappen Tilføj, og kontroller, om teksten er blevet tilføjet eller ej.

Testscenarie – 2 (Test på 4 forskellige browser- og OS-kombinationer)

  1. Navigér til denne URL- https://www.google.com.
  2. Søg efter “LambdaTest”.
  3. Klik på det første testresultat.
  4. Optag nu en Assert, hvis sidetitlen ikke stemmer overens med den forventede titel.

Implementering

De relevante afhængigheder og plugins skal tilføjes i projektets pom.xml. Her er de vigtigste pakker (eller krukker), der er en del af pom.xml:

  • Selenium 4 (Alpha)
  • TestNG-ramme (version 6.9.10)
  • Maven Surefire-plugin til udførelse af testsuite, som er en del af testng.xml
  • Maven Surefire Report-plugin til generering af testresultatrapporten i et HTML-format

Hvis du har til hensigt at tilføje et nyt plugin eller en ny jar til ovenstående pom.xml, skal du søge efter det samme på Maven Repository og tilføje den tilsvarende afhængighed/plugin i det relevante afsnit.

Testpakken indeholder to testtilfælde, nemlig test_Selenium4_ToDoApp() & test_Selenium4_GoogleSearch(). Som det fremgår nedenfor, er implementeringen af disse testcases gemt i separate filer, nemlig CrossBrowserTest.java og GoogleSearchTest.java, og begge er en del af pakken org.selenium4.

Testscenariet test_Selenium4_ToDoApp() er beregnet til at blive udført på Chrome (seneste version) for Windows 10. På den anden side skal testscenariet test_Selenium4_GoogleSearch() udføres på 4 forskellige browser- og OS-kombinationer, dvs. Chrome (nyeste version) på Windows 10, Edge (84.0) på Windows 10, Chrome (nyeste version) på macOS Mojave og Firefox (nyeste version) på OS X Mavericks.

Posterne i testng.xml for test_Selenium4_GoogleSearch() er blevet justeret i overensstemmelse med de browserkapaciteter, der er genereret af LambdaTest-kapacitetsgeneratoren. Nedenfor vises de prøvekapaciteter, der er genereret for Chrome (nyeste) & Windows 10-kombination:

I implementeringen ville vi bruge TestNG-lytterne i Selenium WebDriver til automatiseringstest. På suite-niveau definerer vi klassebetegnelser til at implementere lyttere i TestNG xml-filen. Annotationen @listeners i TestNG bruges til at tilføje klassen org.selenium4.GoogleSearchTest.

Som vist nedenfor vil testnavnet “Google Search Test – 1” tage inputparametre, der angiver browser, version, platform og skærmopløsning. Disse værdier vil blive overført til testmetoden som argumenter ved hjælp af parametrerede annotationer (dvs. @org.testng.annotations.Parameters(value={“browser”, “version”, “platform”, “resolution”})).

1
2
3
4
5
6
7
8
9
10
11
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=”nyeste”/>
<parameter name=”platform” value=”Windows 10″/>
<parameter name=”resolution” value=”1600×1200″/>
<classes>
<class name=”org.selenium4.GoogleSearchTest”/>
</classes>
</test>

CrossBrowserTest.java (Implementering af testscenarie – 1)

GoogleSearchTest.java (Gennemførelse af testscenarie – 2)

Code Walkthrough

Stræk 1 – De nødvendige pakker importeres, før den egentlige gennemførelse starter. Da TestNG-rammen anvendes til testning, importeres dens pakker også, før dens annotationer kan anvendes.

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.*;

Stræk 2 – IExecutionListener bruges til at overvåge start og slutning af testpakken, da testscenariet vil blive udført på forskellige inputkombinationer, der sendes gennem TestNG xml-filen.

IExecutionListener indeholder to metoder – onExecutionStart() og onExecutionFinish(). onExecutionStart() påkaldes før teststart, og onExecutionFinish() påkaldes, når testene/testsuiterne er færdige med at blive udført.

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

Stræk 3 – Den metode, der er implementeret under @BeforeTest-annotationen, vil blive kørt før enhver testmetode, der tilhører klassen under det pågældende tag, bliver kørt. Da vi bruger parameteriseret testning med TestNG, tilføjes annotationen @Parameters(value={“browser”, “version”, “platform”, “resolution”}) til testmetoden.

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 = “bestået”;
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 {
…………………………
…………………………
}

Disse parametre ville blive overdraget værdier fra testng.xml, prøveparameter vist nedenfor:

Stræk 4 – Metoden testSetUp er en parameteriseret metode, der iterativt tager testparametrene fra TestNG.xml, indtil man støder på slutningen af testpakken.

Da testene udføres på Selenium Grid-skyen på LambdaTest, består legitimationsoplysningerne af et brugernavn & et adgangstoken, der kan bruges til at få adgang til LambdaTest Grid – @hub.lambdatest.com/wd/hub.

1
2
3
4
5
6
7
8
9
10
11
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://” + brugernavn + “:” + access_key + “@hub.lambdatest.com/wd/hub”), capabilities);
} catch (MalformedURLException e) {
System.out.println(“Invalid grid URL”);
}
System.out.println(“Startede session”);

RemoteWebDrive API’et bruger fjern-URL’en og browserkapaciteterne, der genereres ved hjælp af LambdaTest-kapacitetsgeneratoren og overføres til metoden i form af inputparametre.

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

Stræk 5 – Testmetoden er implementeret under annotationen @Test. De relevante Selenium-metoder (findElement, sendKeys, submit m.m.) bruges til at finde webelementet og udføre de relevante handlinger på det samme.

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 {
/* Indtast søgeordet i Google-søgefeltet */
search_box = driver.findElement(By.xpath(“//input”)));
search_box.sendKeys(search_string);
search_box.submit();
……………………………………
……………………………………
}
……………………………………
……………………………………
}

Stræk 6 – Blokering af forsinkelser er ikke en god programmeringspraksis, men vi har tilføjet nogle få forsinkelser for at observere output.

1
2
3
4
5
6
7
WebElement lt_link = driver.findElement(By.xpath(“//h3”)));
lt_link.click();
/* Ikke en god programmeringspraksis, tilføjet for demonstrationens skyld */
Thread.sleep(5000);
……………………………………
……………………………………

Stræk 7 – Metoden, der er implementeret under @AfterTest-annotationen, frigør de ressourcer, der er allokeret af den instantierede tilsvarende WebDriver.

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

Testsuite – 2

Testscenarie – 1 (Chrome på Windows 10)

  1. Navigér til webadressen https://lambdatest.com
  2. Kontroller siden Title
  3. Sammenlign sidens titel med den forventede titel
  4. Assert, hvis titlerne ikke stemmer overens

Implementation

Det er det samme som det, der bruges til Testsuite-1, bortset fra artifactId og groupID.

CrossBrowserTest.java

Til demonstration af Maven og Jenkins med Selenium ville vi udføre disse to testsuiter parallelt ved hjælp af FreeStyle-projektet og Jenkins Pipeline.

Woo-hoo! Tak fordi du tilmeldte dig LambdaTests ugentlige nyhedsbrev!

Indstilling af Jenkins til Jenkins Selenium-projektet

Hvor vi opretter et nyt job i Jenkins, der bygger det tidligere nævnte projekt, skal vi opsætte Jenkins-miljøet.

Stræk 1: Installationsstien for JDK skal tilføjes til System Environment Variable. Dette er også nødvendigt for JRE (Java Runtime Environment).

Stræk 2: Download Jenkins i .war-format, og start Jenkins ved at udføre følgende kommando i terminalen:

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=909090

I stedet for 8080 (standardportnummer, der bruges af Jenkins) starter vi Jenkins-tjenesten på port 9090.

Stræk 3: Besøg localhost:9090 i webbrowseren for at begynde at bruge Jenkins.

Opret en ny bruger (med admin-privilegier). Log ind med dette brugernavn for at fortsætte med at bruge Jenkins.

Stræk 4: Da projektet bruger Maven og Jenkins med Selenium, skal de globale indstillinger og stier for Java & Maven konfigureres i Jenkins. For at konfigurere disse indstillinger skal du navigere til “Configure System” i afsnittet “System Configuration”.

I punktet ‘Globale egenskaber’ skal du tilføje følgende miljøvariabler:

1
2
JAVA_HOME – <Sted, hvor JDK er installeret>
MAVEN_HOME – <Sted, hvor Maven er installeret>

I vores tilfælde er posterne som nedenfor:

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

Klik på Anvend og gem.

Tilføjelsen af disse miljøvariabler i Systemkonfiguration gør indstillingerne offentlige (dvs.dvs. kan bruges til Jenkins FreeStyle-projektet og Jenkins Pipeline-projektet).

Stræk 5: HTML Publisher-plugin skal installeres, før der kan udføres postbuild-handlinger for testene. Det samme kan gøres ved at navigere til “Manage Plugins” og søge efter “HTML Publisher Plugin” under fanen “Available”. Klik på ‘Install’ for at installere plugin’et.

Bemærk: Til testning på tværs af browsere anbefales det at bruge Jenkins i .war-formatet, da testene kun udføres i den ikke-headless-tilstand, når Jenkins bruges i .war-formatet.

Selenium Maven Jenkins-integration ved hjælp af FreeStyle-projekt

For at oprette et FreeStyle-projekt, der bruger Selenium Maven Jenkins-integration som demonstration, skal du udføre følgende trin på Jenkins UI (i.f.eks. localhost:9090/)

(Bemærk – Portnummeret varierer afhængigt af den port, der bruges af Jenkins)

Stræk 1: I “Jenkins UI” skal du klikke på “New Item”.

Stræk 2: Indtast jobnavnet som “LambdaTest – Selenium Maven Jenkins integration (Maven Project)”, og vælg “FreeStyle”-projektet.

Jenkins giver også mulighed for at oprette et ‘Maven’-projekt, hvor de konfigurationsindstillinger, der kræves til opsætning af projektet, er minimale. Til denne demonstration har vi dog brugt et ‘FreeStyle’-projekt.

Stræk 3: Gå til ‘Build’ ? ‘Invoke top-level Maven targets’. Maven-versionen skal pege på den version af Maven, der er installeret på maskinen. I vores tilfælde er det Maven 3.6.3.

Stræk 4: Klik på ‘Advanced’ for at indstille målene, indstille placeringen af POM-filer for de to testsuiter. I vores tilfælde er projektplaceringerne nedenfor:

Da vi ønsker at udføre parallelle builds, bruger vi følgende indstilling med mvn-kommandoen:

Da vi vil udføre parallelle builds, bruger vi følgende indstilling med mvn-kommandoen:

1
mvn -T 4 clean install

Denne kommando vil udføre builds med 4 tråde. I afsnittet “Goals” skal du indtaste -T 4 clean install. Det samme mål er sat for Maven-bygningerne for begge projekter. I ‘POM’ skal du angive den absolutte placering af pom.xml

(dvs. Build 1 – C:\Users\Lenovo\IdeaProjects\Maven_Jenkins\pom.xml

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

Stræk 5: “Post-Build-aktionen” er at offentliggøre HTML-rapporter, der giver oplysninger om det overordnede testscenarie (dvs. antal bestået/fejlede/oversprungne tests osv.). Vælg ‘Publish HTML Reports’ i ‘Add post-build action’.

Stræk 6: Maven Surefire Report-plugin’et analyserer de genererede TEST-*.xml-filer under ${project_dir}/target/surefire-reports og renderer dem ved hjælp af DOXIA. I “HTML directory to archive” skal du angive den absolutte sti til den placering, der indeholder surefire-rapporter.

For Test Suite 1:

1
2
3
HTML-mappe til arkivering –

${project_dir_1}/target/surefire-reports
Indeksside(r) – index.html
Rapporttitel – rapport om testscenarie 1

For testsuite 2:

1
2
3
HTML-mappe til arkivering – ${project_dir_2}/target/surefire-reports
Indexside(r) – index.html
Rapporttitel – Rapport om testscenarie 2

Stræk 7: Projektet er nu klar til at blive bygget. Klik på ‘Build Now’ for at udløse build’et.

Stræk 8: Klik på ‘Console Output’ for at se fremskridtene i build-, test- og rapportfaserne.

Stræk 9: Som det ses i ‘Console logs; testene udføres med succes – fem testtilfælde som en del af den første testsuite og et testtilfælde som en del af den anden testsuite.

Her er skærmbillederne af de HTML-rapporter, der genereres for de to testsuiter af HTML Publisher Plugin’et.

Rapport for testscenarie – 1

Rapport for testscenarie – 2

Selenium Maven Jenkins-integration ved hjælp af Jenkins Pipeline

I dette afsnit af demonstrationen af Maven og Jenkins med Selenium, vil vi bruge Jenkins Pipeline, der bruger Domain Specific Language (DSL) til at realisere Pipeline som kode.

Definitionen af en Jenkins Pipeline skrives normalt ind i en fil med navnet Jenkinsfile. Denne fil vil indeholde de trin, der er nødvendige for at køre Jenkins Pipeline. For en hurtig opsummering af den deklarative Jenkins Pipeline kan du tjekke denne Jenkins Pipeline tutorial.

For at integrere Maven og Selenium med Jenkins Pipeline skal du udføre de trin, der er nævnt nedenfor:

Stræk 1: Opret et nyt element med titlen “LambdaTest – Selenium Maven Jenkins integration (Pipeline Project)” af typen “Pipeline”.

Stræk 2: I Pipeline-definitionen skal du indsætte indholdet af Jenkinsfile som vist nedenfor. Klik på Apply (Anvend) og Save (Gem).

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

Stræk 3: I afsnittet efter opbygningen bruges HTML Publisher Plugin til at oprette testrapporterne efter udførelsen for de to testscenarier.

Pipeline Walkthrough

Stræk 1: Dette specifikke Jenkins-job kan køre på en hvilken som helst Agent. Afsnittet med værktøjsdirektivet indeholder alle de værktøjer, der skal installeres automatisk. Det samme tilføjes derefter også til miljøvariablen PATH.

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

På den maskine, hvor testene skal udføres, er JDK 1.8.0_251 og Maven 3.6.3 installeret. Aliasset maven og jdk peger på de respektive Maven- og JDK-versioner.

Stræk 2: Miljødirektivet bruges til at definere miljøvariablerne PROJECT_DIR_1 og PROJECT_DIR_2, der peger på den placering, hvor Java-projekterne er til stede. Disse miljøvariabler kan bruges til alle trin eller trinspecifikke trin, da de er defineret i hovedtrinnet “Run Tests”.’

1
2
3
4
5
6
stadier {
stadie(‘Kør test’) {
miljø {
PROJECT_DIR_1 = “C:\\Users\\Lenovo\IdeaProjects\\\Maven_Jenkins”
PROJECT_DIR_2 = “C:\\Users\\Lenovo\\IdeaProjects\\\Maven_Jenkins_2”
}

Stræk 3: Paralleldirektivet i Jenkins bruges til at udføre Pipeline-stadierne parallelt. I vores tilfælde består Jenkins Pipeline af to faser – testscenarie 1 og testscenarie 2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
stadier {
stadie(‘Kør test’) {
miljø {
PROJECT_DIR_1 = “C:\\Users\\Lenovo\IdeaProjects\\\Maven_Jenkins”
PROJECT_DIR_2 = “C:\\Users\\Lenovo\\IdeaProjects\\\Maven_Jenkins_2”
}
parallel {
stage(‘Testscenarie 1’) {
…………………………………..
…………………………………..
}
stage(‘Testscenario 2’) {
…………………………………..
…………………………………..
}
}
}
}

Stræk 4: De handlinger, der udføres i begge faser, er nøjagtig ens, bortset fra at de udføres på forskellige projekter. Trin “Test Scenario 1” udføres på knudepunktet “Slave_1” og trin “Test Scenario 2” udføres på knudepunktet “Slave_2“.

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

Hvis du har til hensigt at udføre pipelinen på en hvilken som helst agent, kan du springe over at bruge et bestemt agentnavn i disse stadier. Du kan henvise til vores blog Hvad er Jenkins for at forstå oprettelsen af knudepunkter i Jenkins.

I vores tilfælde oprettede vi to knudepunkter (Slave_1 og Slave_2) og gjorde dem online, før vi kørte testene.

Stræk 5: I det næste trin udløses build. Kommandoen mvn clean install udføres derefter på pom.xml, der er til stede i projektmappen. Vi bruger en Windows-maskine til udførelse, og derfor har vi brugt bat-kommandoen (eller batch-kommandoen) til at udløse Maven-bygningen.

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

Stræk 6: Aktionen efter opbygning bruges til at offentliggøre HTML-rapporter for de respektive faser. Handlingerne tilføjes under “post”-direktivet. Vi ønsker kun at påkalde oprettelsen af testrapporten, hvis buildet er vellykket. Derfor er handlingerne under success-direktivet.

Som det ses i demonstrationen med FreeStyle-projektet, er reportDir indstillet til den placering, hvor surefire-rapporter genereres (dvs. ${project_dir}/target/surefire-reports). Feltet reportFiles er indstillet til index.html (dvs. ${project_dir}/target/surefire-reports/index.html).

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

Når pipelinen er tilføjet til Jenkinsfile, skal du klikke på “Build Now” for at starte opbygningsprocessen.

Du kan holde musen hen over et hvilket som helst trin og klikke på “Logs” for at få et kig på udførelsesforløbet for det pågældende trin. Som det fremgår af Stage-snapshotet, udføres de to stages parallelt.

Da vi bruger parallelle stages med deklarativ pipeline i Jenkins, udføres de respektive testcases parallelt på det cloud-baserede Selenium-grid på LambdaTest. Som det fremgår nedenfor, understøtter vores plan på LambdaTest maksimalt fem tests, der skal udføres parallelt.

Som det fremgår nedenfor, er testene blevet udført med succes.

Den samlede udførelsestid var ca. 6 minutter. Du kan holde musen på et hvilket som helst trin for at se de logfiler, der er knyttet til det pågældende trin.

Som det fremgår af de afkortede logfiler, er det tydeligt, at trinene i de to stadier blev udført parallelt:

Her er et skærmbillede af de HTML-rapporter, der genereres som en del af handlingen efter opbygningen:

Fuldførelse

source

Kørsel af Selenium-tests i Jenkins giver fleksibilitet til at køre test, hver gang der sker en softwareændring, og disse ændringer skal testes mod forskellige inputkombinationer. Maven anvendes i Java-projekter, da det letter opgaven med at administrere afhængigheder via pom.xml-filen.

Freestyle-projekter i Jenkins bør anvendes til projekter, der ikke er af høj kompleksitet. Jenkins Pipeline bør bruges, når du ønsker at definere deployment Pipeline som kode. Parallel-direktivet i Jenkins Pipeline bør bruges til at udnytte den parallelle udførelse af Stages i Jenkins. Jenkins Pipeline kan integreres med et cloud-baseret Selenium Grid som LambdaTest, som også giver dig mulighed for at integrere Maven og Jenkins med Selenium på en mere effektiv måde.

Vi håber, at du ved at følge denne vejledning nemt vil kunne integrere Maven og Jenkins med Selenium. Tak fordi du læste!

Himanshu Sheth

Med 7+ års erfaring inden for testautomatisering, BDD, TDD, Himanshu Sheth arbejde som automatiseringsingeniør hos LambdaTest. Han er også en ivrig blogger.

Skrevet af

Skriv et svar

Din e-mailadresse vil ikke blive publiceret.