Articles

Jak integrovat Jenkins a Maven se Seleniem?

On 23 září, 2021 by

Tento článek je součástí našeho Content Hubu. Další podrobné zdroje naleznete v našem obsahovém centru na téma Jenkins Tutorial.

Jenkins je jedním z oblíbených nástrojů pro kontinuální integraci, správu sestavení a automatické testování. Maven je populární nástroj pro automatizaci sestavení, který je široce používán pro projekty Java. Kombinace integrace Selenium, Maven a Jenkins je vrcholem kontinuální integrace a nasazení.

Jako součást automatizačního testování váš tým jistě každý druhý den vymýšlí množství skriptů pro automatizaci testů Selenium. Protože samotné Selenium se pro kontinuální integraci nepoužívá, využívají se Selenium, Maven a integrace Jenkins pro správu sestavení a kontinuální integraci. V tomto článku se podíváme na použití Maven a Jenkins se Seleniem.

Níže je uvedeno stručné shrnutí příspěvku na blogu:

Přehled nástrojů Selenium, Maven, & Jenkins

Maven je populární nástroj pro automatizaci sestavení, který se používá především pro projekty Java. Výhodou použití Mavenu je, že knihovny a zásuvné moduly jazyka Java se stahují dynamicky z centrálního úložiště Mavenu 2.

Závislosti a další podstatné informace týkající se sestavení jsou uloženy v souboru pom.xml projektu. Po stažení jsou závislosti uloženy do místní mezipaměti (.M2 úložiště) a ta je použita pro generování sestavení. To zjednodušuje proces sestavování, protože jakákoli nová závislost projektu musí být přidána pouze do souboru pom.xml, tj. není nutné ruční stahování a instalace balíčků.

Selenium je široce používaný rámec pro automatizaci testování pro ověřování webových aplikací v různých kombinacích prohlížečů, platforem a zařízení (nebo emulátorů). Můžete se podívat na naše blogy o tom, jak lze Selenium Grid použít pro automatizované testování prohlížečů.

Jenkins je open-source CI/CD nástroj, který pomáhá při automatizaci činností souvisejících se sestavením, testováním a nasazením. Jenkins má rozsáhlý ekosystém zásuvných modulů, je open-source a má nadšenou komunitu – faktory, které lze přičíst vlastnostem Jenkinsu.

V tomto blogu Maven a Jenkins se Seleniem bychom použili TestNG, což je populární testovací framework, který je inspirován JUnitem. Je široce používán pro oblasti testování, jako je funkční testování, end-to-end testování a další.

Toto je sada nástrojů, které bychom v ukázce používali:

  • Maven – Nástroj pro správu projektů v jazyce Java
  • TestNG – Populární framework pro automatizaci testů
  • Selenium WebDriver – Knihovna používaná především pro automatizaci interakcí v prohlížeči
  • Jenkins – Nástroj pro kontinuální integraci (CI) a kontinuální nasazení (CD)

Tady je celkový tok informací při použití Selenia, Maven a Jenkins jsou integrovány:

  • Jakmile vývojář vloží kód do úložiště (např.g., GitHub), spustí se sestavení Jenkins.
  • Maven stáhne balíčky závislých knihoven & a začne provádět sestavení. Informace týkající se sady testů jsou k dispozici v souboru testing.xml a stejný soubor je použit také v souboru pom.xml.
  • Nastaví se cíl sestavení (např. instalace) pro spuštění automatických testů. Toho se dosáhne pomocí maven-surefire-plugin.
  • Maven-surefire-plugin říká TestNG, aby spustil testy, které jsou pod anotací @Test.
  • V závislosti na AUT (testované aplikaci) a prohlížeči (&kombinace OS), na kterém jsou prováděny meziprohlížečové testy, vyvolá Selenium WebDriver odpovídající instanci prohlížeče a provede stejné automatizační testy.
  • Výsledky testů jsou publikovány v HTML reportech, protože pro generování reportů se používá zásuvný modul HTML Publisher.
  • I když jeden testovací případ selhal, je celý test označen stavem ‚Neúspěšný.‘

Výhody použití Maven & Jenkins se Seleniem

Předtím, než si ukážeme použití integrace Selenium Maven Jenkins, se podíváme na hlavní výhody použití Maven a Jenkins se Seleniem:

  • Při každé změně v implementaci jsou změny nasazeny na testovací prostředí. Automatické testování probíhá průběžně a vývojáři jsou průběžně informováni o výsledcích sestavení a testovací fáze.
  • Testovací sady, které se skládají z mnoha testovacích scénářů (nebo kombinací testů), mohou při automatickém testování trvat déle. V takových případech lze naplánovat noční běh sestavení a provedení na serveru Jenkins.
  • Jelikož Maven používá pom.xml, snižuje celkovou závislost na ručním stahování souborů jar. Také typ „Maven Project“ v systému Jenkins pomáhá při zahájení integrace Selenium Maven, Jenkins s několika málo konfiguračními nastaveními.
  • Nastavení integrace Selenium Maven Jenkins je vhodné pro vývojové a testovací týmy rozmístěné v různých geografických lokalitách.

Předpoklady pro projekt Selenium Jenkins

Pro demonstraci Maven a Jenkins se Seleniem by měl být na počítači, ze kterého jsou spouštěny testy, nainstalován (nebo dostupný) následující software:

  • Eclipse IDE nebo IntelliJ IDEA (Maven je ve výchozím nastavení v obou těchto IDE)
  • Jenkins v .war formátu
  • Chrome WebDriver odpovídající verzi prohlížeče Chrome na vašem počítači
  • Microsoft Edge Driver
  • Účet na LambdaTestu (protože testy jsou prováděny na cloudové síti Selenium Grid společnosti LambdaTest)

Demonstrace integrace Selenium Maven Jenkins

Pro úsporu času, bychom se nezabývali každým krokem vytváření projektu Maven. V případě, že byste chtěli rychlou rekapitulaci Mavenu se Seleniem, můžete se podívat na tento tutoriál Maven pro automatizaci testů Selenium. Kroky používané při vytváření projektu Maven v prostředí IntelliJ IDEA jsou podobné těm, které se používají při vytváření projektu Maven v prostředí Eclipse IDE.

Testovací sada – 1

Testovací scénář – 1 (Chrome ve Windows 10)

  1. Přejděte na tuto adresu URL- https://lambdatest.github.io/sample-todo-app/.
  2. Zaškrtněte první dvě políčka.
  3. Dole v textovém poli zadejte „Happy Testing at LambdaTest“ s následujícím id = sampletodotext.
  4. Nyní klikněte na tlačítko Add a ověřte, zda byl text přidán, nebo ne.

Testovací scénář – 2 (Testy na 4 různých kombinacích prohlížečů a operačních systémů)

  1. Přejděte na tuto adresu URL- https://www.google.com.
  2. Vyhledejte „LambdaTest“.
  3. Klikněte na první výsledek testu.
  4. Nyní vyvolejte Assert, pokud název stránky neodpovídá očekávanému názvu.

Implementace

V pom.xml projektu je třeba přidat příslušné závislosti a pluginy. Zde jsou klíčové balíčky (nebo jary), které jsou součástí pom.xml:

  • Selenium 4 (Alpha)
  • Framework TestNG (verze 6.9.10)
  • Zásuvný modul Maven Surefire pro provádění testovací sady, který je součástí testng.xml
  • Zásuvný modul Maven Surefire Report pro generování zprávy o výsledcích testů do formátu HTML

Pokud hodláte do výše uvedeného pom přidat nějaký nový zásuvný modul nebo jar.xml, vyhledejte je v repozitáři Maven a přidejte odpovídající závislost/plugin do příslušné sekce.

Testovací sada obsahuje dva testovací případy, a to test_Selenium4_ToDoApp() & test_Selenium4_GoogleSearch(). Jak je uvedeno níže, implementace těchto testovacích případů je uložena v samostatných souborech, konkrétně CrossBrowserTest.java a GoogleSearchTest.java, a oba jsou součástí balíčku org.selenium4.

Testovací scénář test_Selenium4_ToDoApp() je určen k provedení v prohlížeči Chrome (nejnovější verze) pro Windows 10. Naproti tomu testovací scénář test_Selenium4_GoogleSearch() má být proveden na 4 různých kombinacích prohlížečů a operačních systémů, tj. na Chrome (nejnovější verze) pro Windows 10, Edge (84.0) pro Windows 10, Chrome (nejnovější verze) pro macOS Mojave a Firefox (nejnovější verze) pro OS X Mavericks.

Zápisy v souboru testng.xml pro test_Selenium4_GoogleSearch() byly sladěny podle možností prohlížeče vygenerovaných generátorem možností LambdaTest. Níže jsou zobrazeny ukázkové schopnosti vygenerované pro kombinaci Chrome (nejnovější) & Windows 10:

V implementaci bychom pro automatické testování použili posluchače TestNG v Selenium WebDriver. Na úrovni sady definujeme názvy tříd pro implementaci posluchačů v souboru TestNG xml. Anotace @listeners v TestNG slouží k přidání třídy org.selenium4.GoogleSearchTest.

Jak je uvedeno níže, název testu „Google Search Test – 1“ bude přijímat vstupní parametry, které určují prohlížeč, verzi, platformu a rozlišení zobrazení. Tyto hodnoty budou předány metodě testu jako argumenty pomocí parametrizovaných anotací (tj. @org.testng.annotations.Parameters(value={„browser“, „version“, „platform“, „resolution“}).

1
2
3
4
5
6
7
8
9
10
11
12
13
<posluchači>
<posluchači tř.name=“org.selenium4.GoogleSearchTest“/>
</listeners>
<test name=“Test vyhledávání Google – 1″>
<parameter name=“browser“ value=“Chrome“/>
<parameter name=“version“ value=“latest“/>
<parameter name=“platforma“ value=“Windows 10″/>
<parameter name=“rozlišení“ value=“1600×1200″/>
<classes>
<class name=“org.selenium4.GoogleSearchTest“/>
</classes>
</test>

CrossBrowserTest.java (Implementace testovacího scénáře – 1)

GoogleSearchTest.java (Implementace testovacího scénáře – 2)

Procházka kódem

Krok 1 – Před zahájením vlastní implementace se importují potřebné balíčky. Vzhledem k tomu, že pro testování se používá framework TestNG; proto se před použitím jeho anotací importují také jeho balíčky.

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 slouží k monitorování začátku a konce testovací sady, protože testovací scénář by se prováděl na různých kombinacích vstupů, které jsou předávány prostřednictvím xml souboru TestNG.

Příkaz IExecutionListener obsahuje dvě metody – onExecutionStart() a onExecutionFinish(). onExecutionStart() se vyvolá před spuštěním testu a onExecutionFinish() se vyvolá, jakmile testy/sady testů ukončí provádění.

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 implementovaná pod anotací @BeforeTest se spustí před spuštěním jakékoli testovací metody patřící třídě pod touto značkou. Protože používáme parametrizované testování pomocí TestNG, je do testovací metody přidána anotace @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 {
…………………………
…………………………
}

Tyto parametry by byly předávány hodnotami z testng.xml, ukázka parametru je uvedena níže:

Krok 4 – Metoda testSetUp je parametrizovaná metoda, která iterativně přebírá parametry testu z TestNG.xml, dokud nenarazí na konec sady testů.

Jelikož se testy provádějí v cloudu Selenium Grid na LambdaTestu, přihlašovací údaje se skládají z uživatelského jména & přístupového tokenu, který lze použít pro přístup k 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“);
} catch (MalformedURLException e) {
System.out.println(„Invalid grid URL“);
}
System.out.println(„Spuštěna relace“);

Api rozhraní RemoteWebDrive používá vzdálenou adresu URL a možnosti prohlížeče, které jsou generovány pomocí generátoru možností LambdaTest a předány metodě ve formě vstupních parametrů.

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 – Testovací metoda je implementována pod anotací @Test. Pomocí příslušných metod Selenium (findElement, sendKeys, submit a dalších) se vyhledá webový prvek a provedou se s ním příslušné akce.

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 {
/* Zadejte hledaný výraz do vyhledávacího pole Google */
search_box = driver.findElement(By.xpath(„//input“));
search_box.sendKeys(search_string);
search_box.submit();
……………………………………
……………………………………
}
……………………………………
……………………………………
}

Krok 6 – Blokování prodlev není dobrou programátorskou praxí, ale přidali jsme několik prodlev pro sledování výstupu.

1
2
3
4
5
6
7
WebElement lt_link = driver.findElement(By.xpath(„//h3“));
lt_link.click();
/* Není to dobrý programátorský postup, přidáno pro ukázku */
Thread.sleep(5000);
……………………………………
……………………………………

Krok 7 – Metoda, která je implementována pod anotací @AfterTest, uvolní prostředky alokované instancovaným příslušným WebDriverem.

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

Testovací sada – 2

Testovací scénář – 1 (Chrome v systému Windows 10)

  1. Přejděte na adresu URL https://lambdatest.com
  2. Zkontrolujte stránku. Title
  3. Porovnejte název stránky s očekávaným názvem
  4. Potvrdit, pokud se názvy neshodují

Implementace

Je stejná jako ta, která se používá pro Test Suite-1, s výjimkou artefaktId a groupID.

CrossBrowserTest.java

Pro demonstraci Maven a Jenkins se Seleniem bychom tyto dvě testovací sady prováděli paralelně pomocí projektu FreeStyle a Jenkins Pipeline.

Woo-hoo! Díky za přihlášení k odběru týdenního zpravodaje LambdaTest!

Nastavení systému Jenkins pro projekt Jenkins Selenium

Před vytvořením nové úlohy v systému Jenkins, která sestaví výše zmíněný projekt, musíme nastavit prostředí systému Jenkins.

Krok 1: Do systémové proměnné prostředí je třeba přidat instalační cestu JDK. To je nutné také pro JRE (Java Runtime Environment).

Krok 2: Stáhněte si Jenkins ve formátu .war a spusťte Jenkins provedením následujícího příkazu na terminálu:

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

Místo 8080 (výchozí číslo portu používané Jenkinsem) spustíme službu Jenkins na portu 9090.

Krok 3: Navštivte localhost:9090 ve webovém prohlížeči a začněte používat službu Jenkins.

Vytvořte nového uživatele (s právy správce). Přihlaste se pomocí tohoto uživatelského jména a pokračujte v používání nástroje Jenkins.

Krok 4: Vzhledem k tomu, že projekt používá Maven a Jenkins se Seleniem, je třeba v nástroji Jenkins nakonfigurovat globální nastavení a cesty pro Java & Maven. Pro konfiguraci těchto nastavení přejděte do části „Konfigurace systému“ v části „Konfigurace systému“.

V položce ‚Globální vlastnosti‘ přidejte následující proměnné prostředí:

1
2
JAVA_HOME -. <Místo, kde je nainstalováno JDK>
MAVEN_HOME – <Místo, kde je nainstalován Maven>

V našem případě jsou položky následující:

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

Klikněte na Použít a Uložit.

Přidáním těchto proměnných prostředí v Konfiguraci systému se nastavení stane veřejným (tj.Tj. lze je použít pro projekt Jenkins FreeStyle a projekt Jenkins Pipeline).

Krok 5: Před provedením akce po sestavení testů by měl být nainstalován modul HTML Publisher Plugin. Totéž lze provést přechodem na „Manage Plugins“ a vyhledáním „HTML Publisher Plugin“ na kartě „Available“. Pro instalaci zásuvného modulu klikněte na ‚Instalovat‘.

Poznámka: Pro testování napříč prohlížeči se doporučuje používat Jenkins ve formátu .war, protože testy jsou prováděny v režimu bez hlavy pouze při použití Jenkins ve formátu .war.

Integrace Selenium Maven Jenkins pomocí projektu FreeStyle

Pro vytvoření projektu FreeStyle, který používá integraci Selenium Maven Jenkins jako ukázku, proveďte následující kroky v uživatelském rozhraní Jenkins (tj.Tj. localhost:9090/)

(Poznámka – číslo portu se bude lišit podle portu používaného systémem Jenkins)

Krok 1: V uživatelském rozhraní Jenkins klikněte na „New Item“ (Nová položka).

Krok 2: Zadejte název úlohy jako „LambdaTest – Selenium Maven Jenkins integration (Maven Project)“ a vyberte projekt „FreeStyle“.

Jenkins také nabízí možnost vytvořit projekt ‚Maven‘, kde jsou konfigurační nastavení potřebná pro nastavení projektu minimální. Pro tuto ukázku jsme však použili projekt ‚FreeStyle‘.

Krok 3: Přejděte do nabídky ‚Build‘ ? ‚Vyvolat cíle Maven nejvyšší úrovně‘. Verze Mavenu by měla ukazovat na verzi Mavenu nainstalovanou na počítači. V našem případě je to Maven 3.6.3.

Krok 4: Klikněte na ‚Upřesnit‘ a nastavte Cíle, nastavte umístění POM souborů pro dvě testovací sady. V našem případě jsou umístění projektu následující:

Jelikož chceme provádět paralelní sestavení, použijeme následující volbu příkazu mvn:

1
mvn -T 4 clean install

Tento příkaz provede sestavení se 4 vlákny. V části ‚Cíle‘ byste měli zadat -T 4 clean install. Stejný cíl je nastaven pro sestavení Maven pro oba projekty. V části ‚POM‘ zadejte absolutní umístění pom.xml

(tj. sestavení 1 – C:\Users\Lenovo\IdeaProjects\Maven_Jenkins\pom.xml

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

Krok 5: „Akce po sestavení“ spočívá v publikování zpráv HTML, které poskytují informace o celkovém scénáři testování (tj. počet úspěšně/neúspěšně/vynechaných testů atd.). V části ‚Add post-build action‘ (Přidat akci po sestavení) vyberte možnost ‚Publish HTML Reports‘ (Publikovat HTML reporty).

Krok 6: Zásuvný modul Maven Surefire Report analyzuje vygenerované soubory TEST-*.xml v adresáři ${project_dir}/target/surefire-reports a vykreslí je pomocí DOXIA. Do pole ‚Adresář HTML k archivaci‘ zadejte absolutní cestu k tomuto umístění, které obsahuje reporty surefire.

Pro testovací sadu 1:

1
2
3
Adresář HTML pro archivaci -. ${project_dir_1}/target/surefire-reports
Index Page(s) – index.html
Název zprávy – zpráva o testovacím scénáři 1

Pro testovací sadu 2:

1
2
3
HTML adresář k archivaci – ${project_dir_2}/target/surefire-reports
Index Page(s) – index.html
Název zprávy – Zpráva o testovacím scénáři 2

Krok 7: Projekt je nyní připraven k sestavení. Kliknutím na možnost „Build Now“ (Sestavit nyní) spustíte sestavení.

Krok 8: Kliknutím na „Console Output“ (Výstup konzoly) můžete sledovat průběh fází sestavení, testování a sestavení.

Krok 9: Jak je vidět v ‚Console logs; testy jsou úspěšně provedeny – pět testovacích případů jako součást první testovací sady a jeden testovací případ jako součást druhé testovací sady.

Tady jsou snímky obrazovky zpráv HTML, které jsou generovány pro obě testovací sady pomocí modulu HTML Publisher Plugin.

Zpráva pro testovací scénář – 1

Zpráva pro testovací scénář – 2

Integrace Selenium Maven Jenkins pomocí Jenkins Pipeline

V této části ukázky Maven a Jenkins se Seleniem, bychom použili Pipeline Jenkins, která používá jazyk DSL (Domain Specific Language) pro realizaci Pipeline jako kódu.

Definice Jenkins Pipeline se obvykle zapisuje do souboru s názvem Jenkinsfile. Tento soubor by obsahoval kroky potřebné pro spuštění Pipeline Jenkins. Pro rychlou rekapitulaci deklarativního Jenkins Pipeline se můžete podívat na tento návod Jenkins Pipeline.

Pro integraci Maven a Selenium s Jenkins Pipeline musíte provést níže uvedené kroky:

Krok 1: Vytvořte novou položku s názvem ‚LambdaTest – Selenium Maven Jenkins integration (Pipeline Project)‘ typu ‚Pipeline‘.

Krok 2: Do definice Pipeline vložte obsah souboru Jenkinsfile, jak je uvedeno níže. Klikněte na tlačítko Použít a Uložit.

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(‚Testovací scénář 2‘) {
agent {
label „Slave_2“
}
steps {
echo ‚maven clean‘
bat ‚ mvn -f %PROJECT_DIR_2%\\pom.xml clean install‘
}
post {
success {
publishHTML ()
}
}
}
}
}
}
}

Krok 3: V části po sestavení se používá zásuvný modul HTML Publisher Plugin pro vytvoření testovacích zpráv po provedení dvou testovacích scénářů.

Pipeline Walkthrough

Krok 1: Tato konkrétní úloha Jenkins může být spuštěna na libovolném agentovi. Část se směrnicí tools obsahuje všechny nástroje, které je třeba automaticky nainstalovat. Ty se pak také přidají do proměnné prostředí PATH.

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

V počítači, kde budou prováděny testy, je nainstalováno JDK 1.8.0_251 a Maven 3.6.3. V počítači, kde budou prováděny testy, je nainstalováno JDK 1.8.0_251. Aliasy maven a jdk ukazují na příslušné verze Mavenu a JDK.

Krok 2: Směrnice prostředí slouží k definování proměnných prostředí PROJECT_DIR_1 a PROJECT_DIR_2, které ukazují na umístění, kde se nacházejí projekty Java. Tyto proměnné prostředí lze použít pro všechny kroky nebo kroky specifické pro danou etapu, protože jsou definovány v hlavní etapě „Spustit testy.‘

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“
}

Krok 3: Paralelní směrnice v Jenkins se používá pro paralelní provádění fází Pipeline. V našem případě se Pipeline Jenkins skládá ze dvou fází – Testovací scénář 1 a Testovací scénář 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‘) {
…………………………………..
…………………………………..
}
}
}
}

Krok 4: Činnosti prováděné v obou fázích jsou naprosto podobné, pouze se provádějí na různých projektech. Etapa „Test Scenario 1“ je provedena na uzlu „Slave_1“ a etapa „Test Scenario 2“ je provedena na uzlu „Slave_2„.

1
2
3
4
5
6
7
8
9
10
11
paralelně {
stage(‚Testovací scénář 1‘) {
agent {
label „Slave_1“
}
………….
………….
stage(‚Testovací scénář 2‘) {
agent {
label „Slave_2“
}

V případě, že máte v úmyslu spustit pipeline na libovolném agentovi, můžete v těchto fázích vynechat použití konkrétního názvu agenta. Pro pochopení vytváření uzlů v systému Jenkins se můžete podívat na náš blog Co je Jenkins.

V našem případě jsme vytvořili dva uzly (Slave_1 a Slave_2) a před spuštěním testů je uvedli do provozu.

Krok 5: V dalším kroku se spustí sestavení. Poté se spustí příkaz mvn clean install na soubor pom.xml, který se nachází v adresáři projektu. Pro spuštění používáme počítač se systémem Windows, proto jsme pro spuštění sestavení Mavenu použili příkaz bat (nebo dávkový příkaz).

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

Krok 6: Akce po sestavení slouží k publikování zpráv HTML pro příslušné fáze. Akce se přidávají pod direktivu „post“. Vytvoření testovací sestavy chceme vyvolat pouze v případě, že sestavení proběhne úspěšně. Proto jsou akce pod direktivou „success“.

Jak je vidět v ukázce s použitím projektu FreeStyle, reportDir je nastaven na umístění, kde se generují reporty surefire (tj. ${project_dir}/target/surefire-reports). Pole reportFiles je nastaveno na index.html (tj. ${project_dir}/target/surefire-reports/index.html).

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

Po přidání Pipeline do souboru Jenkinsfile klikněte na ‚Build Now‘ pro spuštění procesu sestavování.

Můžete najet na libovolnou etapu a kliknout na ‚Logs‘, abyste se podívali na průběh provádění dané etapy. Jak je vidět ze snímku etapy, obě etapy se provádějí paralelně.

Jelikož v systému Jenkins používáme paralelní etapy s deklarativním Pipeline, příslušné testovací případy se provádějí paralelně v cloudové síti Selenium na LambdaTestu. Jak je uvedeno níže, náš plán na LambdaTestu podporuje paralelní provádění maximálně pěti testů.

Jak je uvedeno níže, testy byly úspěšně provedeny.

Celková doba provádění byla přibližně 6 minut. Najetím na libovolnou fázi můžete zobrazit protokoly spojené s danou fází.

Jak je vidět ze zkrácených protokolů, je zřejmé, že kroky ve dvou etapách se prováděly paralelně:

Tady je snímek obrazovky se sestavami HTML, které se generují v rámci akce po sestavení:

Zabalení

zdroj

Spouštění testů Selenium v systému Jenkins umožňuje flexibilně spouštět testy při každé změně softwaru, přičemž tyto změny je třeba testovat na různých kombinacích vstupů. V projektech Java se používá Maven, protože usnadňuje správu závislostí prostřednictvím souboru pom.xml.

Volné projekty v systému Jenkins by se měly používat pro projekty, které nejsou příliš složité. Jenkins Pipeline by se měl používat, pokud chcete definovat nasazení Pipeline jako kód. Směrnice Parallel v Jenkins Pipeline by měla být použita pro využití paralelního provádění etap v Jenkins. Jenkins Pipeline lze integrovat s cloudovou sítí Selenium Grid, jako je LambdaTest, která také umožňuje efektivněji integrovat Maven a Jenkins se Seleniem.

Doufáme, že podle tohoto návodu budete moci snadno integrovat Maven a Jenkins se Seleniem. Děkujeme za přečtení!

Himanshu Sheth

S více než 7 lety zkušeností v oblasti automatizace testů, BDD, TDD pracuje Himanshu Sheth jako automatizační inženýr ve společnosti LambdaTest. Je také vášnivým bloggerem.

Napsal

Napsal .

Napsat komentář

Vaše e-mailová adresa nebude zveřejněna.