Code coverage is een softwarekwaliteitsmaatstaf die vaak wordt gebruikt tijdens het ontwikkelingsproces en die je in staat stelt om te bepalen welk deel van de code is getest (of uitgevoerd). Om optimale code coverage te bereiken, is het essentieel dat de testimplementatie (of test suites) een meerderheidspercentage van de geïmplementeerde code test.
Er zijn een aantal code coverage tools voor talen zoals Java, C#, JavaScript, enz. Het gebruik van de meest geschikte code coverage tool is belangrijk om het percentage geteste code te begrijpen en passende acties te ondernemen om de ideale code coverage te bereiken.
Voor optimale code testen gebruiken veel bedrijven de JaCoCo-Maven plugin die helpt bij het genereren van gedetailleerde code coverage rapporten. De JaCoCo-Maven plugin is een gratis code coverage bibliotheek voor Java projecten. Het is gebaseerd op onderzoek van bestaande integratielibraries die zijn gemaakt door het EclEmma team. In grote lijnen geeft code coverage wel een korte overzicht van de productkwaliteit, omdat hoe hoger de coverage, des te kleiner de kans dat ongeteste code in de releasecyclus terechtkomt.
In dit artikel zullen we meer leren over de JaCoCo-Maven plugin en hoe deze plugin wordt geïmplementeerd met Maven. We zullen ook een Maven project integreren en een gedetailleerd code coverage rapport genereren voor de tests door Selenium uit te voeren.
Wat Is Code Coverage?
In software ontwikkeling is code coverage een maatstaf die wordt gebruikt om te beschrijven in welke mate de broncode van een applicatie wordt uitgevoerd wanneer een test suite wordt uitgevoerd. Er wordt een rapport gegenereerd om de code coverage van een softwareapplicatie te bekijken en te analyseren. Dit code coverage rapport kan vervolgens worden gebruikt om de codekwaliteit te waarborgen.
De JaCoCo-Maven plugin wordt gebruikt om code coverage rapporten te genereren. Broncode met een hoge code coverage wordt tijdens het testen meer uitgevoerd. Bijvoorbeeld, als de software die u test 100 regels code bevat en het aantal gevalideerde coderegels in de software 90 is, dan zal het code coverage percentage van die software applicatie 90% zijn.
Voordelen van Code Coverage
Code coverage is een zeer nuttige metriek voor ontwikkelaars, testers en QA-ingenieurs. Hier zijn enkele van de belangrijkste voordelen van code coverage:
- Code coverage rapporten bieden nuttige inzichten bij het detecteren en elimineren van dode code. Dit kan worden voorkomen door de beste implementatiepraktijken te volgen, wat uiteindelijk resulteert in verbeterde code onderhoudbaarheid en betere productkwaliteit.
- Kwaliteitsborging kan helpen bij het detecteren van code die niet is afgedekt door de testimplementatie.
- Ontwikkelaars kunnen het software ontwikkelingsproces sneller afwerken, waardoor hun productiviteit, schaalbaarheid en efficiëntie toenemen. Dit resulteert in verkort Time to Market (TTM).
Zoals we weten, is code coverage zeer belangrijk voor elke software product. Nu we een snelle herhaling hebben gedaan over de integrale aspecten van code coverage, laten we eens dieper ingaan op ons kernonderwerp, namelijk het genereren van code coverage rapporten met behulp van de JaCoCo-Maven plugin.
Wat is de JaCoCo-Maven Plugin?
De JaCoCo-Maven (afkorting voor Java Code Coverage) plugin is een open source code coverage tool voor Java. Het creëert code coverage rapporten en integreert goed met IDE’s (Integrated development environments), zoals de Eclipse IDE.
Het integreert ook soepel met CI/CD-gereedschappen (bijv. Jenkins, Circle CI, enz.) en projectbeheergereedschappen (bijv. SonarQube, enz.). Het maakt deel uit van de Eclipse Foundation en heeft het EclEmma-code coverage-gereedschap in Eclipse vervangen.
Hoe werkt het JaCoCo-Maven-plugin?
- Het JaCoCo-Maven-plugin voert de dekking uit door Java-code te instrumenteren via een runtime agent. In eenvoudige termen, je hecht deze agent aan een JVM (Java Virtual Machine) wanneer deze start. Deze agent wordt aangeduid als JaCoCo-agent. De eerste uitvoering start-agent start deze JaCoCo runtime agent.
- Telkens wanneer een klasse wordt geladen, kan JaCoCo de klasse instrumenteren zodat het kan zien wanneer de klasse wordt aangeroepen en welke regels (van code) worden aangeroepen tijdens het testproces. Door dit traject te volgen, bouwt het de code coverage statistieken op, die tijdens de tweede uitvoering (d.w.z. generate-report) op het ritme worden gedaan.
- Standaard wordt het bestand gemaakt zodra de JVM eindigt, maar het is ook mogelijk om de agent in servermodus uit te voeren. Dit activeert een dump van de resultaten en de rapportage wordt gemaakt vóór de beëindiging. Hieronder zijn de interne werkingen van het JaCoCo-plugin weergegeven:
- Je kunt doelen en regels definiëren in de configuratie van het JaCoCo-Maven-plugin. Dit biedt je de flexibiliteit om limieten in te stellen en helpt bij het controleren van de hoeveelheid code coverage.
- Het Maven-surefire-plugin is het standaard Maven-plugin. Dit voert de tests uit in JVM en biedt dekkingsrapporten. Terwijl het JaCoCo-plugin de reeds uitgevoerde code instrumenteert door een plugin (bijv. Surefire-plugin). Daarom is het een goed gebruik om na te kijken of de afhankelijkheid van het maven-surefire-plugin.
Waarom is de JaCoCo-Maven Plugin goed voor code coverage?
De JaCoCo-Maven plugin is geschikt voor code coverage vanwege de volgende redenen:
- Bij het werken aan elk project geven ontwikkelaars de voorkeur aan IDE’s omdat het het coderen en testen vereenvoudigt. JaCoCo kan worden geïnstalleerd in Eclipse IDE onder de naam EclEmma, door EclEmma te downloaden uit de marketplace.
- Het is gemakkelijk om de JaCoCo plugin toe te voegen aan alle soorten builds, inclusief ANT, Maven en Gradle. Het kan ook worden geïntegreerd met CI/CD-tools zoals Jenkins, Circle CI, enz. Dit maakt het veelzijdig voor veel gebruiksgevallen.
- Het code coverage-rapport dat door JaCoCo wordt gegenereerd, is een eenvoudig en informatief HTML-bestand dat in elke browser of IDE kan worden bekeken.
- JaCoCo biedt ook offline instrumentatie (d.w.z. alle klassen worden geïnstrumenteerd voordat er tests worden uitgevoerd).
- Het analyseren van een rapport is ook vrij eenvoudig, aangezien het kleurgebaseerd is en de exacte code coverage-percentage biedt.
Hoe de JaCoCo Plugin met Maven in te stellen
Om code coverage-rapporten te krijgen in een Maven-project, moeten we eerst de JaCoCo Maven plugin voor dat project instellen. Door de JaCoCo plugin te integreren, kunnen de resultaten van de code coverage-analyse worden bekeken als een HTML-rapport. De huidige versie van de JaCoCo-Maven plugin kan worden gedownload van de MVN Repository.
Hier zijn de stappen om de JaCoCo Maven plugin te integreren met een Maven-project:
1. Elk Maven-project heeft een pom.xml bestand, dat wordt gebruikt om alle afhankelijkheden en plugins te declareren. De JaCoCo-Maven plugin wordt in hetzelfde POM.xml bestand gedeclareerd. De XML-code hiervoor is:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
</plugin>Dit is de basis XML-code die onder het build-tag wordt toegevoegd voor het specificeren van de JaCoCo plugin in een op Maven gebaseerd project. We kunnen de functionaliteit verbeteren (zoals het aangeven wanneer een rapport moet worden gegenereerd, enz.) door doelen en regels in het uitvoeringstag te specificeren.
2. Na het versietag voegen we het uitvoeringstag toe. Dit tag bereidt de eigenschappen of uitvoering voor om naar de JaCoCo-agent te verwijzen en wordt doorgegeven als een VM-argument (in dit geval JVM).
3. Voor het uitvoeren van eenvoudige unit tests zullen twee doelen in uitvoeringstags prima werken. Het absolute minimum is het instellen van een prepare-agent en report doelen.
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<execution>
<id>prepare-agent</id>
<goals>
<goal>prepare-agent</goal>
</goals>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
</execution>
</executions>
</plugin>- Prepare-agent doel: Het prepare-agent doel bereidt de JaCoCo-runtimeagent voor om de uitvoeringsgegevens vast te leggen. Het registreert het aantal uitgevoerde regels, teruggetraceerde, enz. Standaard worden de uitvoeringsgegevens geschreven naar het bestand
target/jacoco-ut.exec. - Report doel: Het report doel creëert code coverage rapporten uit de door de JaCoCo-runtimeagent geregistreerde uitvoeringsgegevens. Omdat we de fase-eigenschap hebben gespecificeerd, zullen de rapporten worden gemaakt na de compilatie van de testfase. Standaard worden de uitvoeringsgegevens gelezen uit het bestand
target/jacoco-ut.exec, en wordt het code coverage rapport geschreven naar de directorytarget/site/jacoco/index.html.
4. Voor het uitvoeren van eenvoudige unit tests werkt de bovenstaande configuratie prima. Er moeten echter beperkingen worden opgelegd aan de code coverage rapporten (bijv. specificeren van de bestemmingsdirectory, enz.). Dit kan worden gedaan via een configuratietag:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<execution>
<id>prepare-agent</id>
<goals>
<goal>prepare-agent</goal>
</goals>
<configuration>
<destFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</destFile>
<propertyName>surefireArgLine</propertyName>
</configuration>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
<configuration>
<dataFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</dataFile>
<outputDirectory>${project.reporting.outputDirectory}/jacoco-ut</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>Configuratie van Eerste Uitvoering
Volgens bovenstaande code kunt u enkele tags zien, zoals destFile, enz., die zijn gespecificeerd. Hier is een korte beschrijving van de tags:
destFiletag: DedestFiletag wordt gebruikt voor het instellen van het pad naar het bestand dat de uitvoeringsgegevens bevat.propertyName-surefireArgLinetag: Deze tag stelt de naam van de eigenschap in die de instellingen voor de JaCoCo runtime agent bevat. Dit stelt ook de VM argument lijn in wanneer de unit tests worden uitgevoerd.
Configuratie van Tweede Uitvoering
Volgens bovenstaande code kunt u tags zien zoals dataFile, enz., die zijn gespecificeerd. Hier is een korte beschrijving van de tags:
dataFiletag: DedataFiletag wordt gebruikt om het pad naar het bestand met uitvoeringsgegevens in te stellen.outputDirectorytag: Deze tag stelt de uitvoerdirectory in voor de code coverage rapporten.
5. We kunnen ook regels toevoegen aan onze configuratietag om toezicht te houden op het code coverage percentage. Dit kan als volgt worden gedaan:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<execution>
<id>prepare-agent</id>
<goals>
<goal>prepare-agent</goal>
</goals>
<configuration>
<destFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</destFile>
<propertyName>surefireArgLine</propertyName>
</configuration>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
<configuration>
<dataFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</dataFile>
<outputDirectory>${project.reporting.outputDirectory}/jacoco-ut</outputDirectory>
</configuration>
</execution>
<execution>
<id>jacoco-check</id>
<goals>
<goal>check</goal>
</goals>
<configuration>
<rules>
<rule>
<element>PACKAGE</element>
<limits>
<limit>
<counter>LINE</counter>
<value>COVEREDRATIO</value>
<minimum>0.50</minimum>
</limit>
</limits>
</rule>
</rules>
</configuration>
</execution>
</executions>
</plugin>Configuratie van Derde Uitvoering
Hier wordt een nieuw doelcontrole gedefinieerd. Het jacoco:check doel is gebonden aan het verifiëren van de opgegeven regel. De regel wordt gegeven in de regel tag. Je hebt de flexibiliteit om meer dan één regel op te geven.
- Element tag: Deze tag specificeert het element waarop de regel moet worden toegepast.
- Limit tag: Tags zoals counter, value, minimum, enz., worden gebruikt om de code coverage percentage te beperken. Een commando zoals mvn clean verify kan worden gebruikt om ervoor te zorgen of de regel wordt gevolgd of niet.
6. Er kunnen meerdere doelen en regels worden gedefinieerd in de configuratie van de JaCoCo-Maven plugin.
Code Coverage Rapporten met Maven en de JaCoCo Plugin
In deze sectie zullen we de stappen demonstreren om een code coverage rapport te genereren met behulp van de JaCoCo Maven plugin. De demonstratie gebeurt door een zeer eenvoudig testscenario te nemen. Dus laten we beginnen.
Vereisten
- Maven 3.0 of hoger: Maven is een projectontwikkelings- en begrijpmiddel. Je kunt de nieuwste versie downloaden van de officiële Apache Maven website.
- Java 1.5 of hoger: Je moet ervoor zorgen dat Java op je machine is geïnstalleerd. Als je geen Java hebt geïnstalleerd, download dan de nieuwste versie van Java van de officiële Java website.
- Eclipse IDE voor Java Developers: Hoewel je de IDE van je keuze kunt gebruiken, hebben we voor deze demo de Eclipse IDE gebruikt.
Stappen om een eenvoudig Maven project te maken
- In Eclipse IDE, Ga naar Bestand > Nieuw > Maven Project.
2. Er verschijnt een nieuw dialoogvenster. Zorg ervoor dat het selectievakje “Gebruik standaard werkruimte locatie” is aangevinkt en klik op “Volgende.”
3. Voor het selecteren van het archetype in het project, typ org.apache.maven in het tekstvak dat zich naast de filter bevindt. Selecteer maven-archetype-quickstart en klik op “Volgende.”
4. Geef nu de “Groep-id” op als com.example en de “Artikel-id” als jacoco-example. De “Artikel-id” is de naam van ons project. Klik tenslotte op de knop “Klaar.”
5. U kunt de projectbestands- en maphiërarchie zien in “Project Explorer.”
Hoe de JaCoCo Maven Plugin in POM.xml op te geven
1. Open POM.xml, scrol naar het label. We zullen de JaCoCo-Maven plugin opgeven in het gedeelte dat de Maven plugins opsomt. Kopieer gewoon de onderstaande code en plak deze in het bovenstaande label:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<!--first execution : for preparing JaCoCo runtime agent-->
<execution>
<id>prepare-agent</id>
<goals>
<goal>prepare-agent</goal>
</goals>
</execution>
<!--second execution : for creating code coverage reports-->
<execution>
<id>report</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
</execution>
</executions>
</plugin>2. Aangezien we een rapportage voor automatische webtesten met JUnit demonstreren, zullen we ook de JUnit afhankelijkheid declareren in POM.xml.
Hier is de volledige inhoud van POM.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>jacoco-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>jacoco-example</name>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<!-- JUnit dependencies added to run test cases -->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!-- Maven plugin for Project Management -->
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.0.0</version>
</plugin>
<!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.19.1</version>
</plugin>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<execution>
<id>prepare-agent</id>
<goals><goal>prepare-agent</goal></goals>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals><goal>report</goal></goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>3. Navigeer vanuit de projectdirectory naar de com.example.jacoco_lambdatest package die bestaat in src/main/java. Maak een nieuwe Java-klasse aan met de naam LambdaTest.java. We zullen een eenvoudige setUp() functie in schrijven die de gewenste mogelijkheden van Selenium Grid biedt.
package com.example.Jacoco_lambdatest;
import java.net.MalformedURLException;
import java.net.URL;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
public class LambdaTest {
public static String username = "<LambdaTest_Username>";
public static String accessKey = "<LambdaTest_AccessKey>";
public static DesiredCapabilities setUp() throws Exception {
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability("platform", "Windows 10");
capabilities.setCapability("browserName", "Chrome");
capabilities.setCapability("version", "87.0"); // If this cap isn't specified, it will just get the any available one
capabilities.setCapability("resolution","1024x768");
capabilities.setCapability("build", "First Test");
capabilities.setCapability("name", "Sample Test");
capabilities.setCapability("network", true); // To enable network logs
capabilities.setCapability("visual", true); // To enable step by step screenshot
capabilities.setCapability("video", true); // To enable video recording
capabilities.setCapability("console", true); // To capture console logs
return capabilities;
}
}Toevoegen van JUnit-testgevallen in het project
1. We zullen een eenvoudige JUnit-testcase maken in AppTest.java. Dit wordt standaard geleverd, in de src/test/java onder de pakketnaam com.example.jacoco_lambdatest.
package com.example.Jacoco_lambdatest;
import java.net.MalformedURLException;
import java.net.URL;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import com.example.Jacoco_lambdatest.*;
public class AppTest {
public static RemoteWebDriver driver;
@Test
public void testScript1() throws Exception {
try {
DesiredCapabilities capabilities = LambdaTest.setUp();
String username =LambdaTest.username;
String accessKey = LambdaTest.accessKey;
RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities); driver.get("https://lambdatest.github.io/sample-todo-app/");
driver.findElement(By.name("li1")).click();
driver.findElement(By.name("li2")).click(); driver.findElement(By.id("sampletodotext")).clear(); driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
driver.findElement(By.id("addbutton")).click();
driver.quit();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}Generatie van Code Coverage Rapporten
1. Klik op de knop “Run As” en stel de configuratie in als Maven Test.
2. In plaats daarvan kunt u de cmd (Command Line) openen, naar de projectmap navigeren en de maven-opdracht uitvoeren, “mvn test.”
3. Het uitvoeren van de JUnit-tests zal de JaCoCo-agent automatisch in werking stellen. Er wordt een rapport in binaire indeling gemaakt in de targetmap, met het pad target/jacoco.exec. Het uitvoer van jacoco.exec kan niet alleen worden geïnterpreteerd, maar andere tools zoals SonarQube en plugins kunnen het wel interpreteren. Zoals we eerder hebben aangegeven, zal het doel jacoco:report leesbare code coverage rapporten genereren in populaire formaten zoals HTML, CSV en XML.
4. Aangezien de build succesvol is, ga naar de targetmap, vervolgens naar de site > jacoco map. Het code coverage rapport (d.w.z. index.html) bevindt zich in target/site/jacoco/index.html. Het rapport ziet er zo uit:
5. U kunt inzoomen op micro niveau door op com.example.jacoco_lambdatest>LambdaTest in het rapport te klikken.
6. Door op specifieke functies te klikken, krijgt u een gedetailleerder overzicht in LambdaTest.java.
7. Hier zult u veel diamanten van verschillende kleuren zien, zoals groen, geel en rood. Deze zijn de specificaties die worden gebruikt in het rapport om aan te geven welke coderegel is uitgevoerd en wanneer deze is uitgevoerd. We zullen hier meer over leren in de volgende sectie van de rapportanalyse. Met dit, hebt u succesvol een code coverage rapport gegenereerd via de Jacoco Maven plugin.
Analyse van het Code Coverage Rapport
Ons code coverage rapport toont 94% instructie coverage en 100% tak coverage, wat een uitstekende code coverage score is. Later zullen we proberen een 100% code coverage score te behalen door meer testcases toe te voegen.
De 38 instructies die JaCoCo in het rapport laat zien, verwijzen naar bytecode instructies in plaats van Java code instructies. De JaCoCo rapporten helpen u bij het visueel analyseren van code coverage door gebruik te maken van diamanten met kleuren voor takken en achtergrond kleuren voor regels. Een korte uitleg over de diamanten die in het code coverage rapport worden gezien is hieronder:
- Rode diamant; geeft aan dat geen takken zijn uitgevoerd tijdens de testfase.
- Geel diamant: geeft aan dat de code gedeeltelijk is afgedekt (dat wil zeggen, sommige takken zijn niet uitgevoerd).
- Groene diamant: geeft aan dat alle takken worden uitgevoerd tijdens de test
Dezelfde kleurcode is van toepassing op de achtergrond kleur voor de lijn coverage.
Het rapport biedt voornamelijk drie cruciale metrieken:
- Lijn coverage: Dit geeft weer hoeveel code is uitgevoerd op basis van het aantal Java byte code instructies dat door de tests wordt aangeroepen.
- Branch coverage: Dit toont het percentage uitgevoerde takken in de broncode. Dit zijn typisch if/else of switch statements.
- Cyclomatic complexity: Dit reflecteert de complexiteit van de code via het aantal paden dat nodig is om alle mogelijke paden in een code te dekken. Het verwijst ook naar het aantal testcases dat nodig is om de volledige code te dekken. Aangezien er geen switch of statement in de code staat, zal de cyclomatic complexity één zijn; slechts één uitvoerpadafhankelijkheid is voldoende om de volledige code te dekken.
Invoeren van Meer Test Cases voor het Verbeteren van Code Coverage
1. Om betere code coverage te bereiken, moeten meer tests worden geïntroduceerd die de code testen die eerder niet werd gedekt via de testimplementatie.
2. Ga naar AppTest.java in src/test/java om meer testcases toe te voegen.
3. De nieuwe testcases die aan AppTest.java worden toegevoegd, zullen er als volgt uitzien:
@Test
public void testScript2() throws Exception {
try {
DesiredCapabilities capabilities = LambdaTest.setUp();
String username = LambdaTest.username;
String accessKey = LambdaTest.accessKey;
RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities); driver.get("https://lambdatest.github.io/sample-todo-app/"); driver.findElement(By.name("li2")).click();
driver.findElement(By.name("li3")).click();
driver.findElement(By.id("sampletodotext")).clear(); driver.findElement(By.id("sampletodotext")).sendKeys("Yes, Let's add it to list"); driver.findElement(By.id("addbutton")).click();
driver.quit();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
@Test
public void testScript3() throws Exception {
try {
DesiredCapabilities capabilities = LambdaTest.setUp();
String username = LambdaTest.username;
String accessKey = LambdaTest.accessKey;
RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities); driver.get("https://lambdatest.github.io/sample-todo-app/"); driver.findElement(By.name("li4")).click();
driver.findElement(By.id("sampletodotext")).clear(); driver.findElement(By.id("sampletodotext")).sendKeys("Yes, Let's add it!");
driver.findElement(By.id("addbutton")).click();
driver.quit();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}4. Laten we de Maven JaCoCo rapportage uitvoeren om een nieuw coverage rapport te publiceren.
5. JaCoCo biedt een eenvoudige en gemakkelijke manier om de code coverage score bij te houden door minimale vereisten te declareren. De build mislukt als deze vereisten niet worden voldaan, anders is de build succesvol.
6. Deze vereisten kunnen worden gespecificeerd als regels in POM.xml. Geef gewoon de nieuwe uitvoering door door het ‘check’ doel in POM.xml te specificeren. Voeg de onderstaande code na de tweede <execution> tag in POM.xml toe.
<!--Third execution : used to put a check on the entire package-->
<execution>
<id>jacoco-check</id>
<goals>
<goal>check</goal>
</goals>
<configuration>
<rules>
<rule>
<element>PACKAGE</element>
<limits>
<limit>
<counter>LINE</counter>
<value>COVEREDRATIO</value>
<minimum>0.50</minimum>
</limit>
</limits>
</rule>
</rules>
</configuration>
</execution>7. Met dit, beperken we onze coverage ratio tot 50%. Dit betekent dat minimaal 50% van de code moet worden gedekt tijdens de testfase.
8. U kunt Maven clean verify uitvoeren om te controleren of de in jacoco:check doel ingestelde regels worden nageleefd of niet.
9. Het logboek toont “All coverage checks have been met” omdat ons code coverage score 94% is, wat groter is dan onze minimum 50%.
Automatische Testen op LambdaTest Selenium Grid
Maven Project Gebruikend JaCoCo Plugin
Cloud-based Selenium testing helpt u betere browserdekking, verhoogde testdekking en versnelde tijd tot markt te bereiken. Parallelle testen in Selenium helpt u de bovenstaande vereisten te realiseren.
LambdaTest Cloud Selenium Grid is een cloud-based schaalbare Selenium testplatform waarmee u uw automatiseringsscripts kunt uitvoeren op 2000+ verschillende browsers en besturingssystemen.
Vereisten
Om het testscript met JUnit te gebruiken met Selenium, moeten we een omgeving instellen. U moet eerst een account aanmaken op LambdaTest. Let op de gebruikersnaam en toegangssleutel die beschikbaar zijn in de LambdaTest profielsectie.
We zullen dit voorbeeldproject gebruiken voor Java Selenium testen.
Project importeren in Eclipse IDE
Na het downloaden van een zip-bestand van het project: junit-selenium-sample van GitHub, importeren we het in Eclipse IDE door de onderstaande stappen te volgen:
1. Ga naar je Eclipse IDE, klik op het menu “File” en selecteer “Import.” Er verschijnt een nieuw dialoogvenster.
2. Typ Maven in het tekstvak hieronder en selecteer “Existing Maven Projects,” en klik vervolgens op “Next.”
3. In het volgende dialoogvenster, klik op “Browse” en navigeer naar de projectmap. Schakel ook het selectievakje in dat het pad naar het POM.xml bestand geeft, en klik op “Finish.”
4. Je project wordt succesvol geladen in Eclipse IDE.
Toevoegen van Afhankelijkheden in het POM.xml Bestand
1. Open het POM.xml, voeg nu de afhankelijkheden van JUnit, Selenium en JaCoCo Maven Plugin toe. Na het toevoegen van de afhankelijkheden aan de code van POM.xml zou er zo uit moeten zien:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.lambdatest</groupId>
<artifactId>lambdatest-junit-sample</artifactId>
<version>1.0-SNAPSHOT</version>
<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<surefire.version>2.19.1</surefire.version>
<config.file>default</config.file>
</properties>
<dependencies>
<!--JUnit dependency-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>1.3.2</version>
<scope>test</scope>
</dependency>
<!--Selenium dependency-->
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>2.52.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.googlecode.json-simple</groupId>
<artifactId>json-simple</artifactId>
<version>1.1.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!--Apache Maven Plugins-->
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.19.1</version>
</plugin>
<!--JaCoCo Maven Plugin-->
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<execution>
<id>prepare-agent</id>
<goals><goal>prepare-agent</goal></goals>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals><goal>report</goal></goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project><em><a href="https://github.com/rachnaagrawal/junit-selenium-sample/blob/master/pom.xml" target="_blank" rel="nofollow">Github</a></em>Configureren van de Gewenste Mogelijkheden voor JUnit Automatiserings Testen
1. Om verbinding te maken met LambdaTest Selenium Automation Grid, wordt eerst een remote webdriver aangeroepen. Deze remote driver vereist bepaalde mogelijkheden zoals browser, browserversies, besturingssysteem, enz., om een omgeving te bouwen. De code hiervoor ziet er als volgt uit:
WebDriver driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + "@hub.lambdatest.com/wd/hub"),
DesiredCapabilities.firefox()); //A class named DesiredCapabilities is used to create an environment as a Firefox browser.2. In de JUnit automatiserings testcode, kunnen de mogelijkheden zoals browser, browserversies, besturingssysteem informatie, enz., worden aangepast en worden doorgegeven via het capabilities object.
3. LambdaTest heeft dit proces veel gemakkelijker gemaakt door een ingebouwde capabilities generator te bieden. De capabilities generator genereert automatisch de code voor de gewenste mogelijkheden op basis van uw invoer. Zoals bijvoorbeeld onze configuraties:
|
Velden |
Geselecteerde Waarden |
|
Besturingssystemen |
Windows 10 |
|
Browser |
Chrome |
|
Browser Versie |
62.0 |
|
Resolutie |
1024×768 |
|
Selenium Versie |
3.13.0 |
4. Selecteer de bovenstaande gespecificeerde configuratie in de capabilities generator en plak deze in LambdaTestBseTest.java.
LambdaTest Gebruikersnaam en Toegangssleutel Specificeren in de Vereiste Java Klasse
1. In het Project Explorer ziet u drie Java klassen:
LambdaTestBaseTest.java (bevat de setup vereist voor Java Selenium testing).Parallelized.java(bevat Junit tests voor parallelle testing op LambdaTest Selenium grid).SimpleTest.java(bevat eenvoudige unit tests).
2. LambdaTestBaseTest.java haalt de benodigde gegevens zoals gewenste capabilities, gebruikersnaam en toegangssleutel uit een config bestand. Dit wordt geleverd in src/test/resources als config.json.
3. Specificeer de gewenste capabilities, gebruikersnaam en toegangssleutel in config.json. Dit JSON bestand wordt gebruikt omdat u meerdere configuraties in kunt voorzien voor het realiseren van parallelle testing met Selenium om meerdere configuraties in config.json te specificeren en deze vervolgens later op te halen.
[ { "tunnelName":"LambdaTest tunnel",
"buildName":"running Java Selenium Tests",
"testName":"Jacoco JUnit Test",
"username": "user-name",
"access_key":"access-key",
"operatingSystem" : "win10",
"browserName" : "chrome",
"browserVersion" : "62.0",
"resolution" : "1024x768" }]Unit Testing met JUnit en Selenium:
1. SimpleTest.java is de Java-klasse voor het specificeren van een enkele eenheidstestcase voor het testen en uitvoeren van code-dekking met behulp van de JaCoCo Maven plugin.
package com.lambdatest;
import com.lambdatest.LambdaTestBaseTest;
import org.junit.Test;
import org.openqa.selenium.By;
import static org.junit.Assert.assertEquals;
public class SimpleTest extends LambdaTestBaseTest {
/**
* Simple Test case annotation for JUnit Test
* @throws Exception
*/
@Test
public void validateUser() throws Exception {
driver.get("https://lambdatest.github.io/sample-todo-app/");
driver.findElement(By.name("li1")).click();
driver.findElement(By.name("li2")).click();
driver.findElement(By.id("sampletodotext")).clear();
driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
driver.findElement(By.id("addbutton")).click();
}
}2. Dit is een eenvoudige Selenium WebDriver-test die een voorbeeld to-do-toepassing opent die de volgende taken uitvoert:
- Markeer de eerste twee items als “Klaar.”
- Voeg een nieuw item toe aan de lijst.
- Geef het toegevoegde item terug.
3. Activeer de opdracht mvn test op de terminal om de testcase te bouwen en uit te voeren.
4. Log nu in op uw LambdaTest-account en ga naar “Automatisering.” U zult de tests vinden die u hebt uitgevoerd onder de buildnaam “JUnit JaCoCo Tests.”
5. Klik op “JUnit JaCoCo Tests” en bekijk ze in detail. LambdaTest heeft de video opgenomen. Dus u kunt ook de beelden zien.
Generatie van Code Coverage Rapport via de JaCoCo Maven Plugin:
- Nu, aangezien we de JUnit testcases op LambdaTest Selenium Grid hebben uitgevoerd, zou het code coverage rapport moeten worden gegenereerd via de JaCoCo Maven plugin.
- Ga gewoon naar de targetmap, en u zult de binaire indeling van het rapport vinden als
jacoco.exec. - U kunt de HTML, CSV en XML vorm van het code coverage rapport bekijken in de
target/site/jacocomap alsindex.html, jacoco.csv, enjacoco.xml, respectievelijk. - Nu kunt u ook proberen de code coverage score te verbeteren en het gegenereerde code coverage rapport te analyseren.
Conclusie
In deze artikel hebben we gezien hoe we het JaCoCo-Maven-plugin kunnen gebruiken om code coverage rapporten te genereren voor Java projecten. We hebben ook de beweeglijkheid en schaalbaarheid van LambdaTest Selenium Grid cloud gebruikt om de test processen te automatiseren. Vergeet niet, hoewel, 100% code coverage is niet verantwoordelijk voor het weerspiegelen van effectieve testen, aangezien het alleen de hoeveelheid code aangeeft die tijdens tests wordt uitgevoerd.
Toch helpt het om het aantal fouten te verminderen en de kwaliteit van de software release te verbeteren. Ook voegt het een minimaal overhead toe aan het build proces en stelt het in staat om een bepaalde drempelwaarde te behouden terwijl het ontwikkelteam randgevallen toevoegt of verdedigende programmering implementeert.
Source:
https://dzone.com/articles/how-to-generate-code-coverage-report-jacoco-maven