Comment générer un rapport de couverture de code à l’aide du plugin JaCoCo-Maven

Tutoriels

La couverture de code est un indicateur de qualité logicielle couramment utilisé pendant le processus de développement qui vous permet de déterminer le degré de code qui a été testé (ou exécuté). Pour atteindre une couverture de code optimale, il est essentiel que la mise en œuvre des tests (ou les suites de tests) teste la majorité des pourcentages du code mis en œuvre.

Il existe de nombreux outils de couverture de code pour des langages comme Java, C#, JavaScript, etc. L’utilisation de l’outil de couverture de code le mieux adapté est importante pour comprendre le pourcentage de code testé et prendre les mesures appropriées pour s’assurer d’atteindre la couverture de code idéale.

Pour un test de code optimal, de nombreuses entreprises utilisent le plugin JaCoCo-Maven qui aide à générer des rapports de couverture de code détaillés. Le plugin JaCoCo-Maven est une bibliothèque de couverture de code gratuite pour les projets Java. Il est basé sur l’étude des bibliothèques d’intégration existantes créées par l’équipe EclEmma. Dans une plus grande mesure, la couverture de code donne un aperçu succinct de la qualité du produit car plus la couverture est élevée, moins les chances d’un code non testé d’entrer dans le cycle de mise en production sont élevées.

Dans cet article, nous en apprendrons davantage sur le plugin JaCoCo-Maven et sur la manière dont ce plugin est mis en œuvre à l’aide de Maven. Nous intégrerons également un projet Maven et générerons un rapport de couverture de code détaillé pour les tests en effectuant Selenium.

Qu’est-ce que la couverture de code?

Dans le développement logiciel, la couverture de code est une mesure utilisée pour décrire le degré auquel le code source d’une application est exécuté lorsqu’une suite de tests est exécutée. Un rapport est généré pour visualiser et analyser la couverture de code d’une application logicielle. Ce rapport de couverture de code pourrait ensuite être utilisé pour garantir la qualité du code.

Le plugin JaCoCo-Maven est utilisé pour générer des rapports de couverture de code. Un code source avec une haute couverture de code a davantage de ses lignes de code exécutées lors des tests. Par exemple, si le logiciel que vous testez contient 100 lignes de code et que le nombre de lignes de code validées dans le logiciel est de 90, alors le pourcentage de couverture de code de cette application logicielle sera de 90%.

Avantages de la Couverture de Code

La couverture de code est un indicateur très utile pour les développeurs, les testeurs et les ingénieurs QA. Voici quelques-uns des avantages importants de la couverture de code:

Les rapports de couverture de code fournissent des informations utiles pour la détection et l’élimination de code mort. Cela peut être évité en suivant les meilleures pratiques d’implémentation, ce qui entraîne une meilleure maintenabilité du code et une qualité du produit améliorée.
La qualité assurance peut aider à détecter le code qui n’a pas été couvert par l’implémentation des tests.
Les développeurs peuvent terminer le processus de développement logiciel plus rapidement, augmentant ainsi leur productivité, leur scalabilité et leur efficacité. Cela résulte en une réduction du Time to Market (TTM).

Comme nous le savons, la couverture de code est très importante pour chaque produit logiciel. Maintenant que nous avons fait un bref rappel sur les aspects intégrals de la couverture de code, approfondissons notre sujet principal, à savoir, la génération de rapports de couverture de code à l’aide du plugin JaCoCo-Maven.

Qu’est-ce que le Plugin JaCoCo-Maven?

Le plugin JaCoCo-Maven (abréviation de Java Code Coverage) est un outil open-source de couverture de code pour Java. Il crée des rapports de couverture de code et s’intègre bien avec les IDE (Integrated development environments), comme l’Eclipse IDE.

Il s’intègre également de manière transparente avec les outils CI/CD (par exemple, Jenkins, Circle CI, etc.) et les outils de gestion de projets (par exemple, SonarQube, etc.). Il fait partie de la Fondation Eclipse et a remplacé l’outil de couverture de code EclEmma dans Eclipse.

Comment fonctionne le plugin JaCoCo-Maven?

Le plugin JaCoCo-Maven exécute la couverture en instrumentant le code Java via un agent de runtime. En termes simples, vous attachez cet agent à une JVM (Java Virtual Machine) lorsqu’elle démarre. Cet agent est appelé agent JaCoCo. La première exécution start-agent démarre cet agent de runtime JaCoCo.
Chaque fois qu’une classe est chargée, JaCoCo peut instrumenter la classe afin de pouvoir voir quand la classe est appelée et quelles lignes (de code) sont appelées lors du processus de test. En gardant cette trace, il établit les statistiques de couverture de code, ce qui est fait à la volée lors de la deuxième exécution (c’est-à-dire generate-report).
Par défaut, le fichier est créé dès que la JVM se termine, mais il est également possible d’exécuter l’agent en mode serveur. Cela déclenche un dump des résultats et la création du rapport avant la terminaison. Ci-dessous sont présentées les internes du plugin JaCoCo :

Vous pouvez définir des objectifs et des règles dans la configuration du plugin JaCoCo-Maven. Cela vous offre la flexibilité de définir des limites et aide à vérifier la quantité de couverture de code.
Le plugin Maven-surefire est le plugin Maven par défaut. Cela exécute les tests dans JVM et fournit des rapports de couverture. Alors que le plugin JaCoCo instrumente le code déjà exécuté par un plugin (par exemple, le plugin Surefire). Par conséquent, il est bon de vérifier la dépendance du plugin maven-surefire.

Pourquoi le plugin JaCoCo-Maven est-il bon pour la couverture de code?

Le plugin JaCoCo-Maven est approprié pour la couverture de code pour les raisons suivantes:

Lors du développement de tout projet, les développeurs préfèrent généralement les IDE car cela simplifie l’expérience de codage et de test. JaCoCo peut être installé sur l’IDE Eclipse sous le nom d’EclEmma, en téléchargeant EclEmma depuis son marché.
Il est facile d’ajouter le plugin JaCoCo à tous types de builds, y compris ANT, Maven et Gradle. Il peut également être intégré à des outils CI/CD tels que Jenkins, Circle CI, etc. Cela en fait un outil polyvalent pour de nombreux cas d’utilisation.
Le rapport de couverture de code généré par JaCoCo est un fichier HTML simple et informatif qui peut être consulté dans n’importe quel navigateur ou IDE.
JaCoCo offre également une instrumentation hors ligne (c’est-à-dire que toutes les classes sont instrumentées avant l’exécution de tests).
L’analyse d’un rapport est également assez simple, car elle est basée sur des couleurs et donne le pourcentage exact de couverture de code.

Comment configurer le plugin JaCoCo avec Maven

Pour obtenir des rapports de couverture de code dans un projet Maven, nous devons d’abord configurer le plugin JaCoCo Maven pour ce projet. En intégrant le plugin JaCoCo, les résultats de l’analyse de couverture de code peuvent être revus sous forme de rapport HTML. La version actuelle du plugin JaCoCo-Maven peut être téléchargée à partir du dépôt MVN.

Voici les étapes pour intégrer le plugin JaCoCo Maven avec un projet Maven:

1. Chaque projet Maven possède un fichier pom.xml, utilisé pour déclarer toutes les dépendances et plugins. Le plugin JaCoCo-Maven est déclaré dans le même fichier POM.xml. Le code XML correspondant est :

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.6</version>
</plugin>

Ceci est le code XML de base ajouté sous la balise build pour spécifier le plugin JaCoCo dans un projet basé sur Maven. Nous pouvons améliorer la fonctionnalité (comme mentionner quand un rapport doit être généré, etc.) en spécifiant des objectifs et des règles dans la balise d’exécution.

2. Après la balise de version, nous ajoutons la balise d’exécution. Cette balise prépare les propriétés ou l’exécution pour pointer vers l’agent JaCoCo et est transmise comme argument VM (dans ce cas, JVM).

3. Pour exécuter des tests unitaires simples, deux objectifs définis dans les balises d’exécution fonctionneront correctement. Le strict minimum est de mettre en place des objectifs prepare-agent et report.

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

Objectif prepare-agent: L’objectif prepare-agent prépare l’agent de runtime JaCoCo pour enregistrer les données d’exécution. Il enregistre le nombre de lignes exécutées, déboguées, etc. Par défaut, les données d’exécution sont écrites dans le fichier target/jacoco-ut.exec.
Objectif report: L’objectif report crée des rapports de couverture de code à partir des données d’exécution enregistrées par l’agent de runtime JaCoCo. Comme nous avons spécifié la propriété phase, les rapports seront créés après la compilation de la phase de test. Par défaut, les données d’exécution sont lues à partir du fichier target/jacoco-ut.exec, et le rapport de couverture de code est écrit dans le répertoire target/site/jacoco/index.html.

4. Pour exécuter des tests unitaires simples, la configuration ci-dessus fonctionne correctement. Cependant, nous aurions besoin de mettre des contraintes sur les rapports de couverture de code (par exemple, spécifier le répertoire de destination, etc). Ceci peut être fait via une balise de configuration :

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

Configuration de la première exécution

Comme indiqué dans le code ci-dessus, vous pouvez voir certaines balises, comme destFile, etc., sont spécifiées. Voici une brève description des balises :

destFile balise : La balise destFile est utilisée pour définir le chemin du fichier contenant les données d’exécution.
propertyName-surefireArgLine balise : Cette balise définit le nom de la propriété qui contient les paramètres de l’agent JaCoCo en temps réel. Cela définit également la ligne d’argument VM lorsque les tests unitaires sont exécutés.

Configuration de la deuxième exécution

Comme indiqué dans le code ci-dessus, vous pouvez voir des balises comme dataFile, etc., sont spécifiées. Voici une brève description des balises :

dataFile balise : La balise dataFile est utilisée pour définir le chemin du fichier contenant les données d’exécution.
outputDirectory balise : Cette balise définit le répertoire de sortie pour les rapports de couverture de code.

5. Nous pouvons également ajouter des règles à notre balise de configuration pour contrôler le pourcentage de couverture de code. Ceci peut être fait comme indiqué ci-dessous :

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

Configuration de la troisième exécution

Ici, une nouvelle vérification d’objectif est définie. L’objectif jacoco:check est lié à la vérification de la règle spécifiée. La règle est donnée dans l’étiquette de règle. Vous avez la flexibilité de spécifier plus d’une règle.

Étiquette d’élément: Cette étiquette spécifie l’élément sur lequel la règle doit être appliquée.
Étiquette de limite: Des étiquettes comme compteur, valeur, minimum, etc., sont utilisées pour limiter le pourcentage de couverture de code. Une commande comme mvn clean verify peut être utilisée pour s’assurer que la règle est suivie ou non.

6. Il existe plusieurs objectifs et règles qui peuvent être définis dans la configuration du plugin JaCoCo-Maven.

Rapports de couverture de code à l’aide de Maven et du plugin JaCoCo

Dans cette section, nous allons démontrer les étapes pour générer un rapport de couverture de code à l’aide du plugin Maven JaCoCo. La démonstration est effectuée en prenant un scénario de test très simple. Alors, commençons.

Prérequis

Maven 3.0 ou supérieur: Maven est un outil de gestion et de compréhension du développement de projets. Vous pouvez installer la dernière version sur le site officiel d’Apache Maven.
Java 1.5 ou supérieur: Vous devez vous assurer que Java est installé sur votre machine. Si vous n’avez pas Java installé, veuillez télécharger la dernière version de Java sur le site officiel de Java.
Eclipse IDE for Java Developers: Bien que vous puissiez utiliser l’IDE de votre choix, pour cette démo, nous avons utilisé l’IDE Eclipse.

Étapes pour créer un projet Maven simple

Dans l’IDE Eclipse, allez dans Fichier > Nouveau > Projet Maven.

2. Apparaît une nouvelle boîte de dialogue. Assurez-vous que la case à cocher « Utiliser l’emplacement par défaut du Workspace » est cochée et cliquez sur « Suivant. »

3. Pour sélectionner l’archetype dans le projet, tapez org.apache.maven dans la zone de texte située à côté du filtre. Sélectionnez maven-archetype-quickstart et cliquez sur « Suivant. »

4. Maintenant, spécifiez « Group Id » comme com.example et « Artifact Id » comme jacoco-example. Le « Artifact Id » est le nom de notre projet. Enfin, cliquez sur le bouton « Terminer. »

5. Vous pouvez voir la hiérarchie des fichiers et dossiers du projet dans « Explorateur de projets. »

Comment spécifier le plugin JaCoCo Maven dans le POM.xml

1. Ouvrez POM.xml, faites défiler jusqu’au tag. Nous allons spécifier le plugin JaCoCo-Maven dans la section qui liste les plugins Maven. Copiez simplement le code ci-dessous et collez-le dans le tag ci-dessus :

<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. Comme nous démontrons la génération d’un rapport pour les tests Web automatisés avec JUnit, nous déclarerons également la dépendance JUnit dans POM.xml.

Voici le contenu entier de 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. Depuis le répertoire du projet, naviguez jusqu’au package com.example.jacoco_lambdatest présent dans src/main/java. Créez une nouvelle classe Java nommée LambdaTest.java. Nous allons écrire une simple fonction setUp() qui fournit les capacités souhaitées de Selenium Grid.

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

Ajout de cas de test JUnit dans le projet

1. Nous allons créer un simple cas de test JUnit dans `AppTest.java`. Cela est fourni par défaut, dans `src/test/java` sous le nom de paquet `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());
		}
	}
}

Génération de Rapports de Couverture de Code

1. Cliquez sur le bouton “Run As” et définissez la configuration comme Maven Test.

2. Vous pouvez également ouvrir la ligne de commande (Command Line), naviguer jusqu’au dossier du projet et exécuter la commande Maven, “mvn test.”

3. L’exécution des tests JUnit déclenchera automatiquement l’agent JaCoCo. Il créera un rapport au format binaire dans le répertoire cible, avec le chemin `target/jacoco.exec`. Le résultat de `jacoco.exec` ne peut pas être interprété seul, mais d’autres outils comme SonarQube et des plugins peuvent l’interpréter. Comme nous l’avons précisé précédemment, l’objectif `jacoco:report` génèrera des rapports de couverture de code lisibles dans des formats populaires tels que HTML, CSV et XML.

4. Une fois la construction réussie, rendez-vous dans le dossier cible, puis dans le dossier site > jacoco. Le rapport de couverture de code (c’est-à-dire `index.html`) est situé dans `target/site/jacoco/index.html`. Le rapport ressemble à ceci:

5. Vous pouvez creuser à un niveau micro en cliquant sur `com.example.jacoco_lambdatest>LambdaTest` dans le rapport.

6. En cliquant sur des fonctions spécifiques, vous obtiendrez une vue plus détaillée dans `LambdaTest.java`.

7. Ici, vous verrez de nombreuses diamants de différentes couleurs comme le vert, le jaune et le rouge. Ce sont les spécifications utilisées dans le rapport pour symboliser quelle ligne de code a été exécutée et quand elle a été exécutée. Nous en apprendrons plus à ce sujet dans la section suivante de l’analyse du rapport. Avec cela, vous avez réussi à générer un rapport de couverture de code via le plugin Jacoco Maven.

Analyse du rapport de couverture de code

Notre rapport de couverture de code montre 94% de couverture d’instructions et 100% de couverture de branches, ce qui est un excellent score de couverture de code. Plus tard, nous tenterons d’atteindre un score de couverture de code de 100% en ajoutant plus de cas de test.

Les 38 instructions indiquées par JaCoCo dans le rapport font référence aux instructions de bytecode au lieu des instructions de code Java. Les rapports JaCoCo vous aident à analyser visuellement la couverture de code en utilisant des diamants avec des couleurs pour les branches et des surlignages de fond pour les lignes. Une brève explication des diamants vus dans le rapport de couverture de code est ci-dessous:

Diamant rouge; indique qu’aucune branche n’a été exercée pendant la phase de test.
Diamant jaune: indique que le code est partiellement couvert (c’est-à-dire que certaines branches ne sont pas exercées).
Diamant vert: indique que toutes les branches sont exercées pendant le test

Le même code couleur s’applique au surlignage de fond pour la couverture de ligne.

Le rapport fournit principalement trois métriques cruciales:

Couverture de ligne: Cela reflète la quantité de code exercée en fonction du nombre d’instructions de bytecode Java appelées par les tests.
Couverture des branches: Cela indique le pourcentage de branches exerçées dans le code source. Ce sont typiquement des instructions if/else ou des instructions switch.
Complexité cyclomatique: Cela reflète la complexité du code via le nombre de chemins nécessaires pour couvrir tous les chemins possibles dans un code. Elle fait également référence au nombre de cas de test nécessaires pour mettre en œuvre pour couvrir tout le code. Comme il n’y a ni instruction switch ni instruction dans le code, la complexité cyclomatique sera de un ; un seul chemin d’exécution suffit pour couvrir tout le code.

Introduction de plus de cas de test pour améliorer la couverture du code

1. Pour obtenir une meilleure couverture du code, il faut introduire plus de tests qui testent le code qui n’a pas été couvert auparavant via la mise en œuvre des tests.

2. Allez à AppTest.java dans src/test/java pour ajouter plus de cas de test.

3. Les nouveaux cas de test ajoutés à AppTest.java ressembleront à ceci:

@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. Lançons le rapport Maven JaCoCo pour publier un nouveau rapport de couverture.

5. JaCoCo offre un moyen simple et facile de suivre le score de couverture du code en déclarant des exigences minimales. La build échoue si ces exigences ne sont pas satisfaites, sinon, la build est réussie.

6. Ces exigences peuvent être spécifiées comme des règles dans POM.xml. Il suffit de spécifier la nouvelle exécution en spécifiant le but ‘check’ dans POM.xml. Ajoutez le code ci-dessous après la deuxième balise <execution> dans POM.xml.

<!--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. Avec cela, nous limitons notre ratio de couverture à 50%. Cela signifie qu’au moins 50% du code doit être couvert pendant la phase de test.

8. Vous pouvez exécuter `mvn clean verify` pour vérifier si les règles définies dans le but `jacoco:check` sont respectées ou non.

9. Le journal indique « Toutes les vérifications de couverture ont été satisfaites » car notre score de couverture de code est de 94 %, ce qui est supérieur à notre minimum de 50 %.

Tests Automatisés Sur Le Grille Selenium LambdaTest

Utilisation d’un Projet Maven Avec Le Plugin JaCoCo

Les tests Selenium sur le cloud vous permettent d’atteindre une meilleure couverture de navigateur, une augmentation de la couverture des tests et un accélération du temps de mise sur le marché. Tests parallèles dans Selenium vous aide à réaliser les exigences mentionnées ci-dessus.

LambdaTest Cloud Selenium Grid est une plateforme de test Selenium scalable basée sur le cloud qui vous permet d’exécuter vos scripts d’automatisation sur plus de 2000 navigateurs et systèmes d’exploitation différents.

Prérequis

Pour exécuter le script de test à l’aide de JUnit avec Selenium, nous devons configurer un environnement. Vous devriez d’abord créer un compte sur LambdaTest. Notez bien le nom d’utilisateur et la clé d’accès disponibles dans la section du profil LambdaTest.

Nous utiliserons ce projet exemple pour les tests Selenium en Java.

Importer le Projet dans l’IDE Eclipse

Après avoir téléchargé le fichier zip du projet : `junit-selenium-sample` depuis GitHub, nous l’importerons dans l’IDE Eclipse en suivant les étapes mentionnées ci-dessous :

1. Rendez-vous dans votre IDE Eclipse, cliquez sur le menu “File” et sélectionnez “Import”. Une nouvelle boîte de dialogue apparaît.

2. Tapez Maven dans la zone de texte ci-dessous et sélectionnez “Existing Maven Projects”, puis cliquez sur “Next”.

3. Dans la boîte de dialogue suivante, cliquez sur “Browse” et naviguez jusqu’au dossier du projet. Vérifiez également la case à cocher indiquant le chemin du fichier POM.xml, puis cliquez sur “Finish”.

4. Votre projet sera chargé avec succès dans l’IDE Eclipse.

Ajout des dépendances dans le fichier POM.xml

1. Ouvrez le POM.xml, ajoutez maintenant les dépendances de JUnit, Selenium et JaCoCo Maven Plugin. Après avoir ajouté les dépendances au code du POM.xml, cela devrait ressembler à ceci:

<?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>

Configuration des capacités souhaitées pour les tests d’automatisation JUnit

1. Pour se connecter au Grid d’automatisation Selenium de LambdaTest, la première étape consiste à invoquer un webdriver distant. Ce driver distant nécessite certaines capacités comme le navigateur, les versions du navigateur, le système d’exploitation, etc., pour établir un environnement. Le code correspondant est le suivant:

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. Dans le code des tests d’automatisation JUnit, les capacités telles que le navigateur, les versions du navigateur, les informations sur le système d’exploitation, etc., peuvent être personnalisées et sont transmises via l’objet capabilities.

3. LambdaTest a rendu ce processus très simple en fournissant un générateur de capacités intégré. Le générateur de capacités génèrera automatiquement le code pour les capacités souhaitées en fonction de vos entrées. Par exemple, nos configurations sont les suivantes:

Champs	Valeurs sélectionnées
Systèmes d’exploitation	Windows 10
Navigateur	Chrome
Version du navigateur	62.0
Résolution	1024×768
Version de Selenium	3.13.0

4. Sélectionnez la configuration spécifiée ci-dessus dans le générateur de capacités et collez-la dans LambdaTestBseTest.java.

Spécification du nom d’utilisateur LambdaTest et de la clé d’accès dans la classe Java requise

1. Dans l’Explorateur de projets, vous verrez trois classes Java :

LambdaTestBaseTest.java (contient l’installation nécessaire pour les tests Java Selenium).
Parallelized.java (contient les tests Junit pour les tests parallèles sur le grille Selenium de LambdaTest).
SimpleTest.java (contient des tests unitaires simples).

2. LambdaTestBaseTest.java récupère les données requises comme capacités souhaitées, nom d’utilisateur et clé d’accès à partir d’un fichier de configuration. Cela est fourni dans src/test/resources comme config.json.

3. Spécifiez les capacités souhaitées, le nom d’utilisateur et la clé d’accès dans config.json. Ce fichier JSON est utilisé car vous pouvez y fournir plusieurs configurations pour réaliser des tests parallèles avec Selenium en spécifiant plusieurs configurations dans config.json puis en les récupérant plus tard.

[ { "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" }]

Tests unitaires utilisant JUnit avec Selenium :

1. SimpleTest.java est la classe Java pour spécifier un seul cas de test unitaire pour tester et effectuer la couverture de code à l’aide du plugin JaCoCo Maven.

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. Ceci est un test simple avec Selenium WebDriver qui ouvrira une application d’exemple de liste de tâches à faire et effectuera les tâches suivantes:

Marquer les deux premiers éléments comme “Terminé.”
Ajouter un nouvel élément à la liste.
Retourner l’élément ajouté.

3. Déclenchez la commande mvn test dans le terminal pour construire et exécuter le cas de test.

4. Maintenant, connectez-vous à votre compte LambdaTest et allez à “Automatisation.” Vous trouverez les tests que vous avez effectués sous le nom de build “Tests JUnit JaCoCo.”

5. Cliquez sur “Tests JUnit JaCoCo” et passez en revue-les en détail. LambdaTest a enregistré la vidéo. Vous pouvez donc voir les visuels également.

Génération du rapport de couverture de code via le plugin JaCoCo Maven:

Maintenant, comme nous avons exécuté les cas de test JUnit sur le grid Selenium de LambdaTest, le rapport de couverture de code devrait être généré via le plugin JaCoCo Maven.
Il suffit d’aller dans le dossier cible, et vous trouverez le format binaire du rapport en tant que jacoco.exec.
Vous pouvez consulter le format HTML, CSV et XML du rapport de couverture de code dans le dossier target/site/jacoco comme index.html, jacoco.csv, et jacoco.xml, respectivement.
Vous pouvez également essayer d’améliorer le score de couverture de code et analyser le rapport de couverture de code généré.

Conclusion

Dans cet article, nous avons vu comment utiliser le plugin JaCoCo-Maven pour générer des rapports de couverture de code pour les projets Java. Nous avons également exploité l’agilité et l’évolutivité du cloud LambdaTest Selenium Grid pour automatiser les processus de test. N’oubliez pas, cependant, que 100% de couverture de code n’est pas responsable de refléter un test efficace, car elle ne montre que la quantité de code exécutée lors des tests.

Pourtant, cela aide à réduire le nombre de bogues et améliore la qualité de sortie du logiciel. De plus, cela ajoute un surcoût minimal au processus de construction et permet de maintenir un certain seuil lorsque l’équipe de développement ajoute des cas marginaux ou met en œuvre la programmation défensive.

Source:
https://dzone.com/articles/how-to-generate-code-coverage-report-jacoco-maven