Die Codeabdeckung ist eine Softwarequalitätsmetrik, die im Entwicklungsprozess häufig verwendet wird und es Ihnen ermöglicht, den Grad des getesteten (oder ausgeführten) Codes zu bestimmen. Um eine optimale Codeabdeckung zu erreichen, ist es wesentlich, dass die Testimplementierung (oder Testsuites) den Großteil des implementierten Codes testet.
Es gibt eine Vielzahl von Codeabdeckungstools für Sprachen wie Java, C#, JavaScript usw. Die Verwendung des bestgeeigneten Codeabdeckungstools ist wichtig, um den Prozentsatz des getesteten Codes zu verstehen und entsprechende Maßnahmen zu ergreifen, um die ideale Codeabdeckung zu erreichen.
Für optimales Codetesten nutzen viele Unternehmen den JaCoCo-Maven-Plugin, der detaillierte Codeabdeckungsberichte erstellt. Der JaCoCo-Maven-Plugin ist eine kostenlose Codeabdeckungsbibliothek für Java-Projekte. Es basiert auf der Untersuchung bestehender Integrationsbibliotheken, die von der EclEmma-Gruppe erstellt wurden. In weitem Umfang gibt die Codeabdeckung einen kurzen Überblick über die Produktqualität, da eine höhere Abdeckung weniger Chancen bietet, ungetesteten Code in den Release-Zyklus zu bringen.
In diesem Artikel werden wir mehr über den JaCoCo-Maven-Plugin erfahren und wie dieser Plugin mit Maven implementiert wird. Wir werden auch ein Maven-Projekt integrieren und einen detaillierten Codeabdeckungsbericht für die Tests durch Selenium erstellen.
Was ist Codeabdeckung?
Bei der Softwareentwicklung ist die Codeabdeckung ein Maß, das verwendet wird, um den Grad zu beschreiben, in dem der Quellcode einer Anwendung ausgeführt wird, wenn ein Testsuite ausgeführt wird. Ein Bericht wird erstellt, um die Codeabdeckung einer Softwareanwendung anzuzeigen und zu analysieren. Dieser Codeabdeckungsbericht kann dann zur Sicherstellung der Codequalität verwendet werden.
Der JaCoCo-Maven-Plugin wird verwendet, um Berichte über den Codeabdeckungsgrad zu generieren. Quellcode mit hoher Codeabdeckung wird während der Tests mehr ausgeführt. Beispielsweise, wenn die Software, die Sie testen, 100 Codezeilen enthält und die Anzahl der validierten Codezeilen in der Software 90 beträgt, dann beträgt der Codeabdeckungsprozentsatz dieser Softwareanwendung 90%.
Vorteile der Codeabdeckung
Codeabdeckung ist eine sehr nützliche Metrik für Entwickler, Tester und QA-Ingenieure. Hier sind einige der auffälligsten Vorteile der Codeabdeckung:
- Codeabdeckungsberichte liefern nützliche Einblicke bei der Erkennung und Beseitigung von totem Code. Dies kann durch die Einhaltung von Implementierungsbest-Practices vermieden werden, was wiederum zu verbesserter Codewartbarkeit und besserer Produktqualität führt.
- Qualitätssicherung kann helfen, Code zu erkennen, der mit der Testimplementierung nicht abgedeckt wurde.
- Entwickler können den Softwareentwicklungsprozess schneller abschließen, was ihre Produktivität, Skalierbarkeit und Effizienz erhöht. Dies führt zu verringerter Time to Market (TTM).
Wie wir wissen, ist Codeabdeckung für jedes Softwareprodukt sehr wichtig. Jetzt, da wir eine kurze Zusammenfassung über die integrale Aspekte der Codeabdeckung durchgeführt haben, tauchen wir tiefer in unser Hauptthema ein, nämlich die Generierung von Codeabdeckungsberichten mit dem JaCoCo-Maven-Plugin.
Was ist das JaCoCo-Maven-Plugin?
Das JaCoCo-Maven (Abkürzung für Java Code Coverage) Plugin ist ein Open-Source-Codeabdeckungstool für Java. Es erstellt Codeabdeckungsberichte und integriert sich gut in IDEs (Integrierte Entwicklungsumgebungen), wie beispielsweise das Eclipse IDE.
Es integriert sich auch reibungslos mit CI/CD-Tools (z.B. Jenkins, Circle CI, etc.) und Projektmanagement-Tools (z.B. SonarQube, etc.). Es ist Teil der Eclipse Foundation und hat das EclEmma-Code-Coverage-Tool in Eclipse ersetzt.
Wie funktioniert das JaCoCo-Maven-Plugin?
- Das JaCoCo-Maven-Plugin führt die Abdeckung durch Instrumentieren von Java-Code über einen Laufzeit-Agenten durch. Einfach ausgedrückt, hängen Sie diesen Agenten an eine JVM (Java Virtual Machine) an, wenn sie startet. Dieser Agent wird als JaCoCo-Agent bezeichnet. Der erste Ausführungsstart-Agent startet diesen JaCoCo-Laufzeit-Agenten.
- Sobald eine Klasse geladen wird, kann JaCoCo die Klasse instrumentieren, um zu sehen, wann die Klasse aufgerufen wird und welche Zeilen (des Codes) während des Testprozesses aufgerufen werden. Durch das Verfolgen dieser Spur erstellt es die Codeabdeckungsstatistiken, die während der zweiten Ausführung (d.h. generate-report) im Flugverkehr durchgeführt werden.
- Standardmäßig wird der Datei erstellt, sobald die JVM beendet ist, es ist jedoch auch möglich, den Agenten im Server-Modus zu betreiben. Dies löst ein Dump der Ergebnisse aus und der Bericht wird vor der Beendigung erstellt. Folgend sind die Interna des JaCoCo-Plugins dargestellt:
- Sie können Ziele und Regeln in der Konfiguration des JaCoCo-Maven-Plugins definieren. Dies bietet Ihnen die Flexibilität, Grenzen zu setzen und hilft bei der Überprüfung des Umfangs der Codeabdeckung.
- Das Maven-surefire-Plugin ist das Standard-Maven-Plugin. Dieses führt die Tests in der JVM durch und liefert Abdeckungsberichte. Während das JaCoCo-Plugin den bereits von einem Plugin (z.B. Surefire-Plugin) ausgeführten Code instrumentiert. Daher ist es eine gute Praxis, die Abhängigkeit des maven-surefire-Plugins zu überprüfen.
Warum ist das JaCoCo-Maven-Plugin für die Codeabdeckung gut?
Das JaCoCo-Maven-Plugin ist für die Codeabdeckung geeignet, aus den folgenden Gründen:
- Bei der Arbeit an jedem Projekt bevorzugen Entwickler in der Regel IDEs, da diese das Codieren und Testen vereinfachen. JaCoCo kann im Eclipse-IDE als EclEmma installiert werden, indem EclEmma aus dem Marktplatz heruntergeladen wird.
- Es ist einfach, das JaCoCo-Plugin für alle Arten von Builds hinzuzufügen, einschließlich ANT, Maven und Gradle. Es kann auch mit CI/CD-Tools wie Jenkins, Circle CI usw. integriert werden. Dies macht es für viele Anwendungsfälle vielseitig.
- Der von JaCoCo generierte Codeabdeckungsbericht ist eine einfache und informative HTML-Datei, die in jedem Browser oder IDE betrachtet werden kann.
- JaCoCo bietet auch Offline-Instrumentierung (d. h. alle Klassen werden vor dem Ausführen von Tests instrumentiert).
- Die Analyse eines Berichts ist ebenfalls ziemlich einfach, da sie farbcodiert ist und den genauen Prozentsatz der Codeabdeckung angibt.
Wie man das JaCoCo-Plugin mit Maven einrichtet
Um Codeabdeckungsberichte in einem Maven-Projekt zu erhalten, müssen wir zuerst das JaCoCo-Maven-Plugin für dieses Projekt einrichten. Durch die Integration des JaCoCo-Plugins können die Ergebnisse der Codeabdeckungsanalyse als HTML-Bericht überprüft werden. Die aktuelle Version des JaCoCo-Maven-Plugins kann von der MVN-Repository heruntergeladen werden.
Hier sind die Schritte zur Integration des JaCoCo-Maven-Plugins in ein Maven-Projekt:
1. Jeder Maven-Projekt verfügt über eine Datei namens pom.xml, die verwendet wird, um alle Abhängigkeiten und Plugins zu deklarieren. Der JaCoCo-Maven-Plugin wird im selben pom.xml Datei deklariert. Der XML-Code dafür lautet:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
</plugin>Dies ist der grundlegende XML-Code, der unter dem build-Tag hinzugefügt wird, um den JaCoCo-Plugin in einem Maven-basierten Projekt anzugeben. Wir können die Funktionalität erweitern (wie das Festlegen, wann ein Bericht generiert werden soll usw.) durch das Angeben von Zielen und Regeln im Ausführungs-Tag.
2. Nach dem Version-Tag fügen wir das Ausführungs-Tag hinzu. Dieses Tag bereitet die Eigenschaften oder Ausführung vor, um auf den JaCoCo-Agenten zu verweisen und wird als VM-Argument (in diesem Fall JVM) übergeben.
3. Für das Ausführen einfacher Unit-Tests funktionieren zwei Ziele in Ausführungs-Tags gut. Das Mindeste ist das Einrichten von prepare-agent und report Zielen.
<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 Ziel: Das prepare-agent Ziel bereitet den JaCoCo-Laufzeit-Agenten vor, um die Ausführungsdaten aufzuzeichnen. Es zeichnet die Anzahl der ausgeführten Zeilen, zurückverfolgten usw. auf. Standardmäßig werden die Ausführungsdaten in die Datei
target/jacoco-ut.execgeschrieben. - Report Ziel: Das Report Ziel erstellt Code-Coverage-Berichte aus den von dem JaCoCo-Laufzeit-Agenten aufgezeichneten Ausführungsdaten. Da wir die Phase-Eigenschaft angegeben haben, werden die Berichte nach der Kompilierung der Testphase erstellt. Standardmäßig werden die Ausführungsdaten aus der Datei
target/jacoco-ut.execgelesen und der Code-Coverage-Bericht in dem Verzeichnistarget/site/jacoco/index.htmlgeschrieben.
4. Für das Ausführen einfacher Einheitstests funktioniert die obige Konfiguration gut. Allerdings müssen Einschränkungen für die Codeabdeckungsberichte erfolgen (z.B. Angabe des Zieldateipfads usw.). Dies kann über ein Konfigurationstag erfolgen:
<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>Konfiguration der Ersten Ausführung
Nach dem obigen Code können Sie einige Tags sehen, wie destFile usw., sind angegeben. Hier ist eine kurze Beschreibung der Tags:
destFileTag: DasdestFileTag wird verwendet, um den Pfad zur Datei festzulegen, die die Ausführungsdaten enthält.propertyName-surefireArgLineTag: Dieses Tag legt den Namen der Eigenschaft fest, die die Einstellungen für den JaCoCo-Laufzeit-Agenten enthält. Dies legt auch die VM-Argumentlinie fest, wenn die Einheitstests ausgeführt werden.
Konfiguration der Zweiten Ausführung
Nach dem obigen Code können Sie Tags wie dataFile usw. sehen, sind angegeben. Hier ist eine kurze Beschreibung der Tags:
dataFileTag: DasdataFileTag wird verwendet, um den Pfad zur Datei festzulegen, die die Ausführungsdaten enthält.outputDirectoryTag: Dieses Tag legt das Ausgabeverzeichnis für die Codeabdeckungsberichte fest.
5. Wir können auch Regeln zu unserem Konfigurationstag hinzufügen, um den Codeabdeckungsprozentsatz zu überwachen. Dies kann wie folgt erfolgen:
<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>Konfiguration der Dritten Ausführung
Hier wird eine neue Zielprüfung definiert. Das Ziel jacoco:check ist an die Überprüfung der spezifizierten Regel gebunden. Die Regel wird im Regel-Tag angegeben. Sie haben die Flexibilität, mehr als eine Regel anzugeben.
- Element-Tag: Dieses Tag gibt das Element an, auf das die Regel angewendet werden muss.
- Limit-Tag: Tags wie Zähler, Wert, Mindestwert usw. werden verwendet, um den Prozentsatz der Codeabdeckung zu begrenzen. Ein Befehl wie mvn clean verify kann verwendet werden, um sicherzustellen, ob die Regel eingehalten wird oder nicht.
6. Es können mehrere Ziele und Regeln in der Konfiguration des JaCoCo-Maven-Plugins definiert werden.
Code Coverage Berichte mit Maven und dem JaCoCo-Plugin
In diesem Abschnitt werden wir die Schritte zur Erstellung eines Code Coverage Berichts mit dem JaCoCo Maven Plugin demonstrieren. Die Demonstration erfolgt anhand eines sehr einfachen Testfalls. Also, lasst uns anfangen.
Voraussetzungen
- Maven 3.0 oder höher: Maven ist ein Projektentwicklungs-Management- und Verständnisswerkzeug. Sie können die neueste Version von der offiziellen Apache Maven-Website herunterladen.
- Java 1.5 oder höher: Sie müssen sicherstellen, dass Java auf Ihrem Computer installiert ist. Falls Sie Java nicht installiert haben, laden Sie die neueste Version von Java von der offiziellen Java-Website herunter.
- Eclipse IDE für Java-Entwickler: Obwohl Sie die IDE Ihrer Wahl verwenden können, haben wir für diese Demo die Eclipse IDE verwendet.
Schritte zur Erstellung eines einfachen Maven-Projekts
- In der Eclipse IDE gehen Sie zu Datei > Neu > Maven-Projekt.
2. Es erscheint ein neuer Dialogfenster. Stellen Sie sicher, dass das Kontrollkästchen „Verwenden Sie den Standard-Workspace-Speicherort“ aktiviert ist und klicken Sie auf „Weiter.“
3. Geben Sie zur Auswahl des Archetyps im Projekt org.apache.maven in das Textfeld ein, das sich neben dem Filter befindet. Wählen Sie maven-archetype-quickstart und klicken Sie auf „Weiter.“
4. Geben Sie nun das „Gruppen-Id“ als com.example und das „Artefakt-Id“ als jacoco-example ein. Das „Artefakt-Id“ ist der Projektname. Schließlich klicken Sie auf die Schaltfläche „Fertig stellen.“
5. Sie können die Projektdatei und Ordnerhierarchie im „Projekt-Explorer“ sehen.
Wie man das JaCoCo Maven Plugin im POM.xml spezifiziert
1. Öffnen Sie POM.xml, scrollen Sie zum Tag. Wir werden das JaCoCo-Maven-Plugin in dem Abschnitt spezifizieren, der die Maven-Plugins auflistet. Kopieren Sie einfach den unten stehenden Code und fügen Sie ihn in den oben genannten Tag ein:
<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. Da wir eine Berichtserstellung für automatisierte Web-Tests mit JUnit demonstrieren, werden wir auch die JUnit-Abhängigkeit in POM.xml deklarieren.
Hier ist der gesamte Inhalt von 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. Gehen Sie vom Projektverzeichnis zum com.example.jacoco_lambdatest Paket, das in src/main/java existiert. Erstellen Sie eine neue Java-Klasse namens LambdaTest.java. Wir werden eine einfache setUp()-Funktion darin schreiben, die die gewünschten Fähigkeiten von Selenium Grid bereitstellt.
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;
}
}Hinzufügen von JUnit-Testfällen im Projekt
1. Wir werden einen einfachen JUnit-Testfall in AppTest.java erstellen. Dieser wird standardmäßig unter dem Paketnamen com.example.jacoco_lambdatest im Verzeichnis src/test/java bereitgestellt.
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());
}
}
}Generierung von Code Coverage Reports
1. Klicken Sie auf die Schaltfläche “Run As” und stellen Sie die Konfiguration als Maven Test ein.
2. Alternativ können Sie die Befehlszeile (cmd) öffnen, zum Projektverzeichnis navigieren und den Maven-Befehl “mvn test” ausführen.
3. Beim Ausführen der JUnit-Tests wird der JaCoCo-Agent automatisch in Gang gesetzt. Er erstellt einen Bericht im Binärformat im Zielverzeichnis unter der Pfad target/jacoco.exec. Das Ergebnis von jacoco.exec kann nicht allein interpretiert werden, aber andere Tools wie SonarQube und Plugins können es interpretieren. Wie wir zuvor festgelegt haben, wird das Ziel jacoco:report lesbare Code Coverage-Berichte in beliebten Formaten wie HTML, CSV und XML generieren.
4. Nachdem der Build erfolgreich war, gehen Sie zum Zielverzeichnis, dann zum Verzeichnis site > jacoco. Der Code Coverage-Bericht (d.h. index.html) befindet sich unter target/site/jacoco/index.html. Der Bericht sieht folgendermaßen aus:
5. Sie können auf mikroskopischer Ebene durch Klicken auf com.example.jacoco_lambdatest>LambdaTest im Bericht tiefer eintauchen.
6. Durch Klicken auf spezifische Funktionen erhalten Sie in LambdaTest.java eine detailliertere Ansicht.
7. Hier sehen Sie viele Diamanten in verschiedenen Farben wie Grün, Gelb und Rot. Diese dienen in der Berichterstattung als Symbole, um anzuzeigen, welche Codezeile ausgeführt wurde und wann dies geschah. Mehr dazu erfahren wir in der nächsten Abschnittsanalyse des Berichts. Damit haben Sie erfolgreich einen Codeabdeckungsbericht über den Jacoco Maven-Plugin generiert.
Analyse des Code Coverage Reports
Unser Code Coverage Report zeigt 94% Anweisungsabdeckung und 100% Zweigabdeckung, was ein ausgezeichneter Code Coverage-Score ist. Später werden wir versuchen, einen 100%igen Code Coverage-Score zu erreichen, indem wir weitere Testfälle hinzufügen.
Die 38 Anweisungen, die JaCoCo im Bericht zeigt, beziehen sich auf Bytecode-Anweisungen anstelle von Java-Code-Anweisungen. Die JaCoCo-Berichte helfen Ihnen dabei, die Codeabdeckung visuell zu analysieren, indem Farbdiamanten für Zweige und Hintergrundhöherlegungsfarben für Zeilen verwendet werden. Eine kurze Erklärung der im Code Coverage Report zu sehenden Diamanten finden Sie unten:
- Roter Diamant; zeigt an, dass keine Zweige während der Testphase ausgeführt wurden.
- Gelber Diamant: zeigt an, dass der Code teilweise abgedeckt ist (d.h., einige Zweige wurden nicht ausgeführt).
- Grüner Diamant: zeigt an, dass alle Zweige während des Tests ausgeführt wurden.
Die gleiche Farbcodierung gilt auch für die Hintergrundhöherlegungsfarbe der Zeilenabdeckung.
Der Bericht bietet hauptsächlich drei wesentliche Kennzahlen:
- Zeilenabdeckung: Diese spiegelt die Menge des ausgeführten Codes basierend auf der Anzahl der von den Tests aufgerufenen Java Byte Code-Anweisungen wider.
- Branch coverage: Dies zeigt den Prozentsatz der ausgeführten Verzweigungen im Quellcode. Dies sind typischerweise if/else oder switch-Anweisungen.
- Cyclomatic complexity: Dies spiegelt die Codekomplexität über die Anzahl der Pfade wider, die benötigt werden, um alle möglichen Pfade in einem Code abzudecken. Es bezieht sich auch auf die Anzahl der Testfälle, die erforderlich sind, um den gesamten Code abzudecken. Da es im Code kein Switch oder keine Anweisung gibt, wird die zyklomatische Komplexität eins sein; es reicht ein Ausführungspfad aus, um den gesamten Code abzudecken.
Einführung weiterer Testfälle zur Verbesserung der Codecoverage
1. Um eine bessere Codecoverage zu erreichen, müssen weitere Tests eingeführt werden, die den zuvor durch die Testimplementierung nicht abgedeckten Code testen.
2. Gehen Sie zu AppTest.java in src/test/java um weitere Testfälle hinzuzufügen.
3. Die neuen Testfälle, die zu AppTest.java hinzugefügt werden, werden wie folgt aussehen:
@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. Lassen Sie uns den Maven JaCoCo-Bericht ausführen, um einen neuen Abdeckungsbericht zu veröffentlichen.
5. JaCoCo bietet eine einfache und leicht verständliche Möglichkeit, die Codecoverage-Ergebnisse zu verfolgen, indem minimale Anforderungen festgelegt werden. Der Build schlägt fehl, wenn diese Anforderungen nicht erfüllt sind, andernfalls ist der Build erfolgreich.
6. Diese Anforderungen können als Regeln in POM.xml angegeben werden. Geben Sie einfach die neue Ausführung durch Angabe des Ziels ‘check’ in POM.xml an. Fügen Sie den folgenden Code nach dem zweiten <execution>-Tag in POM.xml ein.
<!--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. Damit begrenzen wir unseren Abdeckungsgrad auf 50%. Dies bedeutet, dass während der Testphase mindestens 50% des Codes abgedeckt sein sollten.
8. Sie können `mvn clean verify` ausführen, um zu überprüfen, ob die in der `jacoco:check`-Zielvorgabe festgelegten Regeln eingehalten werden oder nicht.
9. Der Log zeigt „Alle Abdeckungsprüfungen wurden erfüllt“, da unser Abdeckungsscore 94 % beträgt, was unserem Mindestwert von 50 % übersteigt.
Automatisierte Tests auf LambdaTest Selenium Grid
Verwendung eines Maven-Projekts mit dem JaCoCo-Plugin
Selenium-Tests in der Cloud helfen Ihnen, eine bessere Browserabdeckung, erhöhte Testabdeckung und beschleunigte Zeit bis zum Marktstart zu erreichen. Parallele Tests in Selenium helfen Ihnen, die oben genannten Anforderungen zu erfüllen.
Die LambdaTest Cloud Selenium Grid ist eine cloudbasierte skalierbare Selenium-Testplattform, die es Ihnen ermöglicht, Ihre Automatisierungsskripte auf über 2000 verschiedenen Browsern und Betriebssystemen auszuführen.
Voraussetzungen
Um das Testskript mit JUnit und Selenium auszuführen, müssen wir eine Umgebung einrichten. Zunächst benötigen Sie ein Konto bei LambdaTest. Achten Sie darauf, den Benutzernamen und den Access-Key aufzuschreiben, die im Abschnitt Profil von LambdaTest verfügbar sind.
Wir werden dieses Beispielprojekt für Java-Selenium-Tests verwenden.
Importieren des Projekts in die Eclipse IDE
Nachdem Sie die Zip-Datei des Projekts: `junit-selenium-sample` von GitHub heruntergeladen haben, importieren wir es in die Eclipse IDE, indem wir die folgenden Schritte befolgen:
1. Öffnen Sie Ihr Eclipse IDE, klicken Sie auf das Menü „Datei“ und wählen Sie „Importieren“. Es erscheint ein neuer Dialogfeld.
2. Geben Sie im Textfeld unten „Maven“ ein und wählen Sie „Vorhandene Maven-Projekte“, und klicken Sie dann auf „Weiter“.
3. Im nächsten Dialogfeld klicken Sie auf „Durchsuchen“ und navigieren Sie zum Projektordner. Aktivieren Sie auch das Kontrollkästchen, das den Pfad zum POM.xml-Datei angibt, und klicken Sie auf „Fertig stellen“.
4. Ihr Projekt wird erfolgreich in Eclipse IDE geladen.
Hinzufügen von Abhängigkeiten im POM.xml-Datei
1. Öffnen Sie die POM.xml, fügen Sie nun die Abhängigkeiten von JUnit, Selenium und JaCoCo Maven Plugin hinzu. Nach dem Hinzufügen der Abhängigkeiten zum Code der POM.xml sollte es wie folgt aussehen:
<?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>Konfigurieren der gewünschten Fähigkeiten für JUnit-Automatisierungstests
1. Um eine Verbindung zum LambdaTest Selenium Automation Grid herzustellen, wird zunächst ein Remote-WebDriver aufgerufen. Dieser Remote-Driver benötigt einige Fähigkeiten wie Browser, Browserversionen, Betriebssystem usw. zur Erstellung einer Umgebung. Der Code dafür sieht wie folgt aus:
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. Im JUnit-Automatisierungstestcode können Fähigkeiten wie Browser, Browserversionen, Betriebssysteminformationen usw. angepasst und über das Fähigkeitenobjekt übergeben werden.
3. LambdaTest hat diesen Prozess durch die Bereitstellung eines integrierten Fähigkeiten-Generators sehr vereinfacht. Der Fähigkeiten-Generator generiert automatisch den Code für die gewünschten Fähigkeiten basierend auf Ihren Eingaben. Zum Beispiel sind unsere Konfigurationen:
|
Felder |
Ausgewählte Werte |
|
Betriebssysteme |
Windows 10 |
|
Browser |
Chrome |
|
Browser-Version |
62.0 |
|
Auflösung |
1024×768 |
|
Selenium-Version |
3.13.0 |
4. Wählen Sie die oben genannte Konfiguration in der Fähigkeiten-Generator aus und fügen Sie sie in LambdaTestBaseTest.java ein.
Spezifizieren des LambdaTest-Benutzernamens und des Zugriffsschlüssels in der erforderlichen Java-Klasse
1. Im Projektexplorer sehen Sie drei Java-Klassen:
LambdaTestBaseTest.java (enthält die für Java Selenium-Tests erforderliche Einrichtung).Parallelized.java(enthält Junit-Tests für parallele Tests auf dem LambdaTest Selenium-Grid).SimpleTest.java(enthält einfache Einheitstests).
2. LambdaTestBaseTest.java holt die erforderlichen Daten wie gewünschte Fähigkeiten, Benutzername und Zugriffsschlüssel aus einer Konfigurationsdatei. Dies wird in src/test/resources als config.json bereitgestellt.
3. Geben Sie die gewünschten Fähigkeiten, Benutzername und Zugriffsschlüssel in config.json an. Diese JSON-Datei wird verwendet, da Sie mehrere Konfigurationen darin für die Realisierung paralleler Tests mit Selenium angeben können, um mehrere Konfigurationen in config.json anzugeben und sie später abzurufen.
[ { "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" }]Einheitstesten mit JUnit und Selenium:
1. SimpleTest.java ist die Java-Klasse zur Spezifikation eines einzelnen Testfalls für Tests und die Durchführung von Codeabdeckung mithilfe des JaCoCo Maven-Plugins.
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. Dies ist ein einfacher Selenium WebDriver-Test, der eine Beispiel-To-Do-Anwendung öffnet und die folgenden Aufgaben ausführt:
- Markieren Sie die ersten beiden Elemente als “Fertig.”
- Fügen Sie ein neues Element zur Liste hinzu.
- Gebe das hinzugefügte Element zurück.
3. Starten Sie den Befehl `mvn test` im Terminal, um den Testfall zu erstellen und auszuführen.
4. Melden Sie sich jetzt bei Ihrem LambdaTest-Konto an und gehen Sie zu “Automatisierung”. Dort finden Sie die ausgeführten Tests unter dem Build-Namen “JUnit JaCoCo Tests”.
5. Klicken Sie auf “JUnit JaCoCo Tests” und überprüfen Sie sie detailliert. LambdaTest hat das Video aufgezeichnet. Sie können auch die visuellen Inhalte ansehen.
Generierung des Code Coverage Reports über das JaCoCo Maven Plugin:
- Nachdem wir nun die JUnit-Testfälle auf dem LambdaTest Selenium Grid ausgeführt haben, sollte der Code Coverage Report über das JaCoCo Maven Plugin generiert werden.
- Gehen Sie einfach zum Ordner `target`, und Sie finden die binäre Form des Berichts als
jacoco.exec. - Sie können die HTML-, CSV- und XML-Form des Code Coverage Reports im Ordner
target/site/jacocounterindex.html, jacoco.csvundjacoco.xmljeweils anzeigen. - Jetzt können Sie auch versuchen, die Code Coverage-Score zu verbessern und den generierten Code Coverage Report zu analysieren.
Schlussfolgerung
In diesem Artikel haben wir gesehen, wie man das JaCoCo-Maven-Plugin verwendet, um Abdeckungsberichte für Java-Projekte zu erstellen. Wir haben auch die Agilität und Skalierbarkeit des LambdaTest Selenium Grid Cloud genutzt, um den Testprozess zu automatisieren. Denken Sie jedoch daran, dass 100%ige Codeabdeckung nicht dafür verantwortlich ist, effektives Testen widerzuspiegeln, da sie nur die Menge des während der Tests ausgeführten Codes zeigt.
Dennoch hilft es, die Anzahl der Fehler zu reduzieren und die Qualität der Software-Veröffentlichung zu verbessern. Darüber hinaus fügt es dem Buildprozess nur minimale Overhead hinzu und ermöglicht es, einen gewissen Schwellenwert beizubehalten, wenn das Entwicklungsteam Randfälle hinzufügt oder defensives Programmieren implementiert.
Source:
https://dzone.com/articles/how-to-generate-code-coverage-report-jacoco-maven