La copertura del codice è una metrica di qualità del software comunemente utilizzata durante il processo di sviluppo che ti permette di determinare il grado di codice che è stato testato (o eseguito). Per ottenere una copertura del codice ottimale, è essenziale che l’implementazione dei test (o le suite di test) testi una percentuale maggioritaria del codice implementato.
Esistono numerosi strumenti di copertura del codice per linguaggi come Java, C#, JavaScript, ecc. Utilizzare lo strumento di copertura del codice più adatto è importante per comprendere la percentuale di codice testato e adottare le azioni appropriate per garantire che si raggiunga la copertura del codice ideale.
Per un test del codice ottimale, molte aziende utilizzano il plugin JaCoCo-Maven che aiuta a generare rapporti dettagliati sulla copertura del codice. Il plugin JaCoCo-Maven è una libreria di copertura del codice gratuita per progetti Java. È basato sull’analisi di librerie di integrazione esistenti create dalla squadra di EclEmma. In una certa misura, la copertura del codice fornisce una panoramica sommaria della qualità del prodotto perché maggiore è la copertura, minori sono le possibilità che del codice non testato venga inserito nel ciclo di rilascio.
In questo articolo, impareremo di più sul plugin JaCoCo-Maven e su come questo plugin viene implementato utilizzando Maven. Integreremo anche un progetto Maven e genereremo un rapporto dettagliato sulla copertura del codice per i test eseguiti tramite Selenium.
Che cos’è la copertura del codice?
Nello sviluppo del software, la copertura del codice è una misura utilizzata per descrivere il grado in cui il codice sorgente di un’applicazione viene eseguito quando una suite di test viene eseguita. Viene generato un rapporto per visualizzare e analizzare la copertura del codice di un’applicazione software. Questo rapporto sulla copertura del codice può quindi essere utilizzato per garantire la qualità del codice.
Il plugin JaCoCo-Maven viene utilizzato per generare rapporti di copertura del codice. Il codice sorgente con una copertura del codice elevata ha più parti del suo codice eseguite durante i test. Ad esempio, se il software che si sta testando contiene 100 righe di codice e il numero di righe di codice verificate nel software è 90, allora la percentuale di copertura del codice di quell’applicazione software sarà del 90%.
Vantaggi della Copertura del Codice
La copertura del codice è una metrica molto utile per sviluppatori, tester e ingegneri QA. Ecco alcuni dei principali vantaggi della copertura del codice:
- I rapporti di copertura del codice forniscono utili informazioni per la rilevazione ed eliminazione di codice morto. Ciò può essere evitato seguendo le migliori pratiche di implementazione, che a loro volta portano a una maggiore manutenibilità del codice e a una migliore qualità del prodotto.
- La qualità del software può aiutare a rilevare il codice che non è stato coperto utilizzando l’implementazione dei test.
- Gli sviluppatori possono concludere il processo di sviluppo del software più rapidamente, aumentando la loro produttività, scalabilità ed efficienza. Ciò si traduce in una riduzione del Tempo al Mercato (TTM).
Come sappiamo, la copertura del codice è molto importante per ogni prodotto software. Ora che abbiamo fatto un rapido riepilogo sui principali aspetti della copertura del codice, approfondiamo il nostro argomento principale, ovvero la generazione di rapporti di copertura del codice utilizzando il plugin JaCoCo-Maven.
Che cos’è il Plugin JaCoCo-Maven?
Il plugin JaCoCo-Maven (abbreviazione di Java Code Coverage) è uno strumento open-source di copertura del codice per Java. Crea rapporti di copertura del codice e si integra bene con IDE (Integrated development environments), come l’Eclipse IDE.
Si integra anche in modo fluido con gli strumenti CI/CD (ad esempio Jenkins, Circle CI, ecc.) e gli strumenti di gestione dei progetti (ad esempio, SonarQube, ecc.). Fa parte della Eclipse Foundation e ha sostituito lo strumento di copertura del codice EclEmma in Eclipse.
Come Funziona il Plugin JaCoCo-Maven?
- Il plugin JaCoCo-Maven esegue la copertura instrumentando il codice Java attraverso un agente di runtime. In termini semplici, si collega questo agente a una JVM (Java Virtual Machine) quando viene avviata. Questo agente è denominato agente JaCoCo. Il primo avvio dell’agente avvia questo agente di runtime JaCoCo.
- Ogni volta che una classe viene caricata, JaCoCo può instrumentare la classe in modo da poter vedere quando la classe viene chiamata e quali righe (di codice) vengono chiamate durante il processo di test. Tenendo traccia di questo, costruisce le statistiche di copertura del codice, che viene fatto in tempo reale durante la seconda esecuzione (cioè generate-report).
- Per impostazione predefinita, il file viene creato non appena la JVM termina, ma è anche possibile eseguire l’agente in modalità server. Ciò innesca un dump dei risultati e viene creato il rapporto prima della terminazione. Mostrato di seguito sono gli interni del plugin JaCoCo:
- Puoi definire obiettivi e regole nella configurazione del plugin JaCoCo-Maven. Questo ti offre la flessibilità di impostare limiti e aiuta a verificare la quantità di copertura del codice.
- Il plugin Maven-surefire è il plugin Maven predefinito. Questo esegue i test in JVM e fornisce rapporti di copertura. Mentre il plugin JaCoCo instrumenta il codice già eseguito da un plugin (ad esempio, plugin Surefire). Pertanto, è una buona pratica verificare la dipendenza del plugin maven-surefire.
Perché il plugin JaCoCo-Maven è buono per la copertura del codice?
Il plugin JaCoCo-Maven è adatto per la copertura del codice per i seguenti motivi:
- Durante lo sviluppo di qualsiasi progetto, i programmatori prediligono generalmente gli IDE perché semplificano l’esperienza di codifica e test. JaCoCo può essere installato su Eclipse IDE con il nome di EclEmma, scaricando EclEmma dal suo marketplace.
- È facile aggiungere il plugin JaCoCo a tutti i tipi di build, inclusi ANT, Maven e Gradle. Può anche essere integrato con strumenti CI/CD come Jenkins, Circle CI, ecc. Ciò lo rende versatile per molti casi d’uso.
- Il rapporto di copertura del codice generato da JaCoCo è un file HTML semplice e informativo che può essere visualizzato in qualsiasi browser o IDE.
- JaCoCo offre anche un’istruzione offline (cioè tutte le classi sono instrumentate prima di eseguire qualsiasi test).
- L’analisi di un rapporto è anche abbastanza semplice, poiché è basata su colori e fornisce la percentuale esatta di copertura del codice.
Come configurare il plugin JaCoCo con Maven
Per ottenere rapporti di copertura del codice in un progetto Maven, è necessario prima configurare il plugin JaCoCo Maven per quel progetto. Integrando il plugin JaCoCo, i risultati dell’analisi della copertura del codice possono essere rivisti come rapporto HTML. La versione corrente del plugin JaCoCo-Maven può essere scaricata dal repository MVN.
Ecco i passaggi per integrare il plugin JaCoCo Maven con un progetto Maven:
1. Ogni progetto Maven ha un file pom.xml, utilizzato per dichiarare tutte le dipendenze e i plugin. Il plugin JaCoCo-Maven viene dichiarato nello stesso file POM.xml. Il codice XML per lo stesso è:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
</plugin>Questo è il codice XML di base aggiunto sotto la tag build per specificare il plugin JaCoCo in un progetto basato su Maven. Possiamo migliorare la funzionalità (come specificare quando generare un rapporto, ecc.) specificando obiettivi e regole nella tag execution.
2. Dopo la tag versione, aggiungiamo la tag execution. Questa tag prepara le proprietà o l’esecuzione per puntare all’agente JaCoCo e viene passata come argomento VM (in questo caso, JVM).
3. Per eseguire semplici test di unità, due obiettivi impostati nelle tag execution funzioneranno bene. Il minimo indispensabile è impostare gli obiettivi prepare-agent e 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>- Obiettivo prepare-agent: L’obiettivo prepare-agent prepara l’agente runtime JaCoCo per registrare i dati di esecuzione. Registra il numero di righe eseguite, backtraced, ecc. Per impostazione predefinita, i dati di esecuzione vengono scritti nel file
target/jacoco-ut.exec. - Obiettivo report: L’obiettivo report crea rapporti di copertura del codice dai dati di esecuzione registrati dall’agente runtime JaCoCo. Poiché abbiamo specificato la proprietà fase, i rapporti verranno creati dopo la compilazione della fase di test. Per impostazione predefinita, i dati di esecuzione vengono letti dal file
target/jacoco-ut.exece il rapporto di copertura del codice viene scritto nella directorytarget/site/jacoco/index.html.
4. Per eseguire semplici test di unità, la configurazione sopra descritta funziona bene. Tuttavia, avremmo bisogno di mettere delle restrizioni sui rapporti di copertura del codice (ad esempio, specificare la directory di destinazione, ecc). Questo può essere fatto tramite un tag di configurazione:
<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>Configurazione della Prima Esecuzione
Come per il codice sopra, puoi vedere che sono specificati alcuni tag, come destFile, ecc. Ecco una breve descrizione dei tag:
destFiletag: Il tagdestFileviene utilizzato per impostare il percorso del file che contiene i dati di esecuzione.propertyName-surefireArgLinetag: Questo tag imposta il nome della proprietà che contiene le impostazioni per l’agente runtime JaCoCo. Imposta anche la linea di argomento VM quando vengono eseguiti i test di unità.
Configurazione della Seconda Esecuzione
Come per il codice sopra, puoi vedere che sono specificati tag come dataFile, ecc. Ecco una breve descrizione dei tag:
dataFiletag: Il tagdataFileviene utilizzato per impostare il percorso del file che contiene i dati di esecuzione.outputDirectorytag: Questo tag imposta la directory di output per i rapporti di copertura del codice.
5. Possiamo anche aggiungere regole al nostro tag di configurazione per controllare la percentuale di copertura del codice. Questo può essere fatto come mostrato di seguito:
<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>Configurazione della Terza Esecuzione
Qui, viene definito un nuovo controllo obiettivo. L’obiettivo jacoco:check è vincolato a verificare la regola specificata. La regola è data nell’etichetta rule. Hai la flessibilità di specificare più di una regola.
- Etichetta elemento: Questa etichetta specifica l’elemento su cui la regola deve essere applicata.
- Etichetta limite: Etichette come counter, value, minimum, ecc., vengono utilizzate per limitare la percentuale di copertura del codice. Un comando come mvn clean verify può essere utilizzato per assicurarsi che la regola sia seguita o meno.
6. Esistono più obiettivi e regole che possono essere definite nella configurazione del plugin JaCoCo-Maven.
Report di copertura del codice utilizzando Maven e il plugin JaCoCo
In questa sezione, dimostreremo i passaggi per generare un rapporto di copertura del codice utilizzando il plugin Maven JaCoCo. La dimostrazione viene fatta prendendo uno scenario di test molto semplice. Quindi, iniziamo.
Prerequisiti
- Maven 3.0 o superiore: Maven è uno strumento di gestione e comprensione dello sviluppo del progetto. Puoi installare la versione più recente dal sito web ufficiale di Apache Maven.
- Java 1.5 o superiore: Devi assicurarti che Java sia installato sul tuo computer. Nel caso in cui non abbiate installato Java, per favore scaricate la versione più recente di Java dal sito web ufficiale di Java.
- IDE Eclipse per sviluppatori Java: Anche se puoi utilizzare l’IDE del tuo scelta, per questa demo abbiamo utilizzato l’IDE Eclipse.
Passaggi per creare un semplice progetto Maven
- In Eclipse IDE, vai su File > Nuovo > Progetto Maven.
2. Appare una nuova finestra di dialogo. Assicurati che la casella di controllo “Usa la posizione predefinita della Workspace” sia selezionata e clicca su “Avanti.”
3. Per selezionare l’archetipo nel progetto, digita org.apache.maven nella casella di testo situata accanto al filtro. Seleziona maven-archetype-quickstart e clicca su “Avanti.”
4. Ora, specifica il “Group Id” come com.example e il “Artifact Id” come jacoco-example. Il “Artifact Id” è il nome del nostro progetto. Infine, clicca sul pulsante “Fine.”
5. Puoi vedere la gerarchia dei file e delle cartelle del progetto nella “Project Explorer.”
Come Specificare il Plugin JaCoCo Maven in POM.xml
1. Apri POM.xml, scorri fino al tag. Specifichiamo il plugin JaCoCo-Maven nella sezione che elenca i plugin Maven. Copia semplicemente il codice qui sotto e incollalo nel tag sopra:
<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. Poiché stiamo dimostrando la generazione di un rapporto per i test web automatizzati con JUnit, dichiareremo anche la dipendenza JUnit in POM.xml.
Ecco il contenuto completo di 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. Dalla directory del progetto, passa al pacchetto com.example.jacoco_lambdatest presente in src/main/java. Crea una nuova classe Java chiamata LambdaTest.java. Scriveremo una semplice funzione setUp() che fornisce le capacità desiderate di 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;
}
}Aggiunta di Casi di Test JUnit nel Progetto
1. Creeremo un semplice caso di test JUnit in AppTest.java. Questo viene fornito per impostazione predefinita, in src/test/java sotto il nome del pacchetto 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());
}
}
}Generazione di Report di Copertura del Codice
1. Fare clic sul pulsante “Run As” e impostare la configurazione come Maven Test.
2. In alternativa, è possibile aprire il cmd (Command Line), spostarsi nella cartella del progetto e eseguire il comando maven, “mvn test.”
3. Eseguire i test JUnit attiverà automaticamente l’agente JaCoCo. Creerà un report in formato binario nella directory target, con il percorso target/jacoco.exec. L’output di jacoco.exec non può essere interpretato singolarmente ma altri strumenti come SonarQube e plugin possono interpretarlo. Come abbiamo specificato in precedenza, l’obiettivo jacoco:report genererà report di copertura del codice leggibili in formati popolari come HTML, CSV e XML.
4. Con il build riuscito, vai alla cartella target, poi alla cartella site > jacoco. Il report di copertura del codice (cioè index.html) si trova in target/site/jacoco/index.html. Il report appare così:
5. È possibile approfondire a livello micro facendo clic su com.example.jacoco_lambdatest>LambdaTest nel report.
6. Cliccando su funzioni specifiche, si avrà una visione più dettagliata in LambdaTest.java.
7. Qui, vedrai molti diamanti di colori diversi come verde, giallo e rosso. Queste sono le specifiche utilizzate nel rapporto per simboleggiare quale linea di codice è stata eseguita e quando è stata eseguita. Impareremo di più a riguardo nella prossima sezione dell’analisi del rapporto. Con questo, hai generato con successo un rapporto di copertura del codice tramite il plugin Jacoco Maven.
Analisi del Rapporto di Copertura del Codice
Il nostro rapporto di copertura del codice mostra una copertura delle istruzioni del 94% e una copertura delle branch del 100%, che è un ottimo punteggio di copertura del codice. In seguito, cercheremo di raggiungere un punteggio di copertura del codice del 100% aggiungendo più casi di test.
Le 38 istruzioni mostrate da JaCoCo nel rapporto si riferiscono alle istruzioni di bytecode anziché alle istruzioni di codice Java. I rapporti JaCoCo ti aiutano a analizzare visivamente la copertura del codice utilizzando diamanti colorati per le branch e colori di sfondo per le linee. Una breve spiegazione dei diamanti osservati nel rapporto di copertura del codice è riportata di seguito:
- Diamante rosso; indica che nessuna branch è stata esercitata durante la fase di test.
- Diamante giallo: indica che il codice è parzialmente coperto (cioè, alcune branch non sono state esercitate).
- Diamante verde: indica che tutte le branch sono state esercitate durante il test
Lo stesso codice colore si applica allo sfondo colorato per la copertura delle linee.
Il rapporto fornisce principalmente tre metriche cruciali:
- Copertura delle linee: Questa riflette la quantità di codice esercitata in base al numero di istruzioni di bytecode Java chiamate dai test.
- Copertura dei rami: Questo mostra la percentuale di rami esercitati nel codice sorgente. Questi sono tipici se/altrimenti o istruzioni switch.
- Complessità ciclomatica: Questo riflette la complessità del codice attraverso il numero di percorsi necessari per coprire tutti i possibili percorsi in un codice. Si riferisce anche al numero di casi di test necessari per implementare per coprire l’intero codice. Poiché non ci sono switch o istruzioni nel codice, la complessità ciclomatica sarà uno; un solo percorso di esecuzione è sufficiente per coprire l’intero codice.
Introduzione di Più Casi di Test per Migliorare la Copertura del Codice
1. Per ottenere una migliore copertura del codice, è necessario introdurre più test che testano il codice che non è stato coperto in precedenza tramite l’implementazione del test.
2. Vai a AppTest.java in src/test/java per aggiungere più casi di test.
3. I nuovi casi di test aggiunti a AppTest.java appariranno come segue:
@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. Eseguiamo il report di JaCoCo di Maven per pubblicare un nuovo report di copertura.
5. JaCoCo offre un modo semplice ed efficace per tracciare il punteggio di copertura del codice dichiarando requisiti minimi. La build fallisce se questi requisiti non sono soddisfatti, altrimenti la build è riuscita.
6. Questi requisiti possono essere specificati come regole in POM.xml. Basta specificare la nuova esecuzione specificando l’obiettivo ‘check’ in POM.xml. Aggiungi il codice seguente dopo la seconda <execution> tag in 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. Con questo, limitiamo il nostro rapporto di copertura al 50%. Ciò significa che almeno il 50% del codice deve essere coperto durante la fase di test.
8. Puoi eseguire Maven clean verify per verificare se le regole impostate nell’obiettivo jacoco:check sono rispettate o meno.
9. Il log mostra “Tutti i controlli di copertura sono stati soddisfatti” poiché il nostro punteggio di copertura del codice è del 94%, che è superiore al nostro minimo del 50%.
Test di Automazione su LambdaTest Grid Selenium
Utilizzo di un Progetto Maven con il Plugin JaCoCo
I test Selenium in cloud ti consentono di ottenere una migliore copertura dei browser, un aumento della copertura dei test e un tempo di mercato accelerato. Test paralleli in Selenium ti aiutano a raggiungere i requisiti sopra menzionati.
LambdaTest Cloud Selenium Grid è una piattaforma di test Selenium scalabile basata sulla cloud che ti consente di eseguire i tuoi script di automazione su oltre 2000 browser diversi e sistemi operativi.
Prerequisiti
Per eseguire lo script di test utilizzando JUnit con Selenium, è necessario configurare un ambiente. Prima di tutto, è necessario creare un account su LambdaTest. Assicurati di prendere nota del nome utente e della chiave di accesso disponibili nella sezione del profilo di LambdaTest.
Utilizzeremo questo progetto di esempio per i test Selenium in Java.
Importazione del Progetto in Eclipse IDE
Dopo aver scaricato il file zip del progetto: junit-selenium-sample da GitHub, lo importeremo in Eclipse IDE seguendo i passaggi seguenti:
1. Vai al tuo IDE Eclipse, clicca sul menu “File” e seleziona “Import.” Appare una nuova finestra di dialogo.
2. Digita Maven nella casella di testo sottostante e seleziona “Existing Maven Projects,” quindi clicca “Next.”
3. Nella finestra di dialogo successiva, clicca su “Browse” e naviga fino alla cartella del progetto. Inoltre, seleziona la casella di controllo che fornisce il percorso al file POM.xml, e clicca “Finish.”
4. Il tuo progetto verrà caricato correttamente nell’IDE Eclipse.
Aggiunta di Dipendenze nel File POM.xml
1. Apri il POM.xml, ora aggiungi le dipendenze di JUnit, Selenium e JaCoCo Maven Plugin. Dopo aver aggiunto le dipendenze, il codice del POM.xml dovrebbe apparire così:
<?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>Configurazione delle Capacità Desiderate per i Test di Automazione JUnit
1. Per connettersi al Grid di Automazione Selenium di LambdaTest, la prima cosa da fare è richiamare un webdriver remoto. Questo driver remoto richiede alcune capacità come browser, versioni del browser, sistema operativo, ecc., per creare un ambiente. Il codice per questo è il seguente:
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. Nei test di automazione JUnit, le capacità come browser, versioni del browser, informazioni sul sistema operativo, ecc., possono essere personalizzate e vengono passate tramite oggetto capabilities.
3. LambdaTest ha semplificato questo processo fornendo un generatore di capacità integrato. Il generatore di capacità genererà automaticamente il codice per le capacità desiderate in base ai tuoi input. Ad esempio, le nostre configurazioni sono:
|
Campi |
Valori Selezionati |
|
Sistemi Operativi |
Windows 10 |
|
Browser |
Chrome |
|
Versione Browser |
62.0 |
|
Risoluzione |
1024×768 |
|
Versione Selenium |
3.13.0 |
4. Selezionare la configurazione specificata sopra nel generatore di capacità e incollarla in LambdaTestBaseTest.java.
Specifica Username e Chiave di Accesso LambdaTest nella Classe Java Richiesta
1. Nello Spazio Progetti, vedrai tre classi Java:
LambdaTestBaseTest.java (contiene la configurazione richiesta per i test Java Selenium).Parallelized.java(contiene test Junit per test paralleli sulla griglia Selenium di LambdaTest).SimpleTest.java(contiene semplici test di unità).
2. LambdaTestBaseTest.java recupera i dati richiesti come capacità desiderate, username e chiave di accesso da un file di configurazione. Questo è fornito in src/test/resources come config.json.
3. Specifica le capacità desiderate, username e chiave di accesso in config.json. Questo file JSON viene utilizzato poiché puoi fornire più configurazioni al suo interno per realizzare test paralleli con Selenium specificando più configurazioni in config.json e poi recuperarle in seguito.
[ { "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" }]Test di Unità Utilizzando JUnit con Selenium:
1. SimpleTest.java è la classe Java per specificare un singolo caso di test unitario per testare e eseguire la copertura del codice utilizzando il 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. Questo è un semplice test Selenium WebDriver che aprirà un’applicazione di esempio per gestire liste di cose da fare che eseguirà le seguenti attività:
- Segna i primi due elementi come “Fatto.”
- Aggiungi un nuovo elemento alla lista.
- Restituisci l’elemento aggiunto.
3. Attiva il comando mvn test nel terminale per compilare ed eseguire il caso di test.
4. Ora, accedi al tuo account LambdaTest e vai a “Automazione.” Troverai i test che hai eseguito sotto il nome di build “Test JUnit JaCoCo.”
5. Fai clic su “Test JUnit JaCoCo” e rivisitali in dettaglio. LambdaTest ha registrato il video. Quindi puoi vedere anche le immagini.
Generazione del Rapporto di Copertura del Codice tramite il Plugin JaCoCo Maven:
- Ora, poiché abbiamo eseguito i casi di test JUnit su LambdaTest Selenium Grid, il rapporto di copertura del codice dovrebbe essere generato tramite il plugin JaCoCo Maven.
- Basta andare alla cartella target, e troverai il formato binario del rapporto come
jacoco.exec. - Puoi visualizzare il formato HTML, CSV e XML del rapporto di copertura del codice nella cartella
target/site/jacococomeindex.html, jacoco.csv, ejacoco.xml, rispettivamente. - Ora puoi anche provare a migliorare il punteggio di copertura del codice e analizzare il rapporto di copertura del codice generato.
Conclusione
In questo articolo, abbiamo visto come utilizzare il plugin JaCoCo-Maven per generare rapporti di copertura del codice per progetti Java. Abbiamo anche sfruttato l’agilità e la scalabilità di LambdaTest Selenium Grid cloud per automatizzare i processi di test. Ricorda, però, che il100% di copertura del codice non è responsabile di riflettere un test efficace, poiché mostra solo la quantità di codice esercitata durante i test.
Tuttavia, aiuta a ridurre il numero di bug e migliora la qualità del software rilasciato. Inoltre, aggiunge un sovraccarico minimo al processo di build e consente di mantenere una certa soglia mentre l’équipe di sviluppo aggiunge casi limite o implementa la programmazione difensiva.
Source:
https://dzone.com/articles/how-to-generate-code-coverage-report-jacoco-maven