La cobertura de código es una métrica de calidad de software comúnmente utilizada durante el proceso de desarrollo que te permite determinar el grado de código que ha sido probado (o ejecutado). Para lograr una cobertura de código óptima, es esencial que la implementación de pruebas (o suites de pruebas) pruebe un porcentaje mayoritario del código implementado.
Existen numerosos herramientas de cobertura de código para lenguajes como Java, C#, JavaScript, etc. Utilizar la herramienta de cobertura de código más adecuada es importante para comprender el porcentaje de código probado y tomar las medidas apropiadas para asegurar que se alcance la cobertura de código ideal.
Para una prueba de código óptima, muchas empresas utilizan el plugin JaCoCo-Maven que ayuda a generar informes detallados de cobertura de código. El plugin JaCoCo-Maven es una biblioteca de cobertura de código gratuita para proyectos Java. Se basa en el estudio de bibliotecas de integración existentes creadas por el equipo de EclEmma. En mayor medida, la cobertura de código da una visión general breve de la calidad del producto porque cuanto mayor sea la cobertura, menor serán las posibilidades de que el código sin probar ingrese al ciclo de lanzamiento.
En este artículo, aprenderemos más sobre el plugin JaCoCo-Maven y cómo se implementa utilizando Maven. También integraremos un proyecto Maven y generaremos un informe detallado de cobertura de código para las pruebas realizando Selenium.
¿Qué es la cobertura de código?
En el desarrollo de software, la cobertura de código es una medida utilizada para describir el grado en que el código fuente de una aplicación se ejecuta cuando se ejecuta una suite de pruebas. Se genera un informe para ver y analizar la cobertura de código de una aplicación de software. Este informe de cobertura de código podría entonces ser utilizado para asegurar la calidad del código.
El plugin JaCoCo-Maven se utiliza para generar informes de cobertura de código. El código fuente con una alta cobertura de código tiene más de su código ejecutado durante las pruebas. Por ejemplo, si el software que está probando contiene 100 líneas de código y el número de líneas de código validadas en el software es de 90, entonces el porcentaje de cobertura de código de esa aplicación de software será del 90%.
Beneficios de la Cobertura de Código
La cobertura de código es una métrica muy útil para desarrolladores, testers y ingenieros de QA. A continuación, se presentan algunos de los beneficios destacados de la cobertura de código:
- Los informes de cobertura de código proporcionan información útil en la detección y eliminación de código muerto. Esto se puede evitar siguiendo las mejores prácticas de implementación, lo que a su vez resulta en una mejor mantenibilidad del código y una mejor calidad del producto.
- La aseguramiento de la calidad puede ayudar a detectar código que no ha sido cubierto utilizando la implementación de pruebas.
- Los desarrolladores pueden completar el proceso de desarrollo de software más rápido, aumentando su productividad, escalabilidad y eficiencia. Esto resulta en una reducción del Tiempo hasta el Mercado (TTM).
Como sabemos, la cobertura de código es muy importante para cada producto de software. Ahora que hemos hecho un repaso rápido sobre los aspectos integrales de la cobertura de código, profundicemos en nuestro tema central, es decir, la generación de informes de cobertura de código utilizando el plugin JaCoCo-Maven.
¿Qué es el Plugin JaCoCo-Maven?
El plugin JaCoCo-Maven (abreviatura de Cobertura de Código Java) es una herramienta de código abierto para la cobertura de código en Java. Crea informes de cobertura de código e integra bien con IDEs (entornos de desarrollo integrado), como el IDE de Eclipse.
También se integra sin problemas con herramientas de CI/CD (por ejemplo, Jenkins, Circle CI, etc.) y herramientas de gestión de proyectos (por ejemplo, SonarQube, etc.). Es parte de la Fundación Eclipse y ha reemplazado a la herramienta de cobertura de código EclEmma en Eclipse.
¿Cómo funciona el plugin JaCoCo-Maven?
- El plugin JaCoCo-Maven ejecuta la cobertura instrumentando el código Java a través de un agente de tiempo de ejecución. En términos sencillos, adjuntas este agente a una JVM (Máquina Virtual Java) cuando se inicia. A este agente se le conoce como agente JaCoCo. La primera ejecución start-agent inicia este agente de tiempo de ejecución JaCoCo.
- Cada vez que se carga una clase, JaCoCo puede instrumentar la clase para que pueda ver cuándo se llama a la clase y qué líneas (de código) se llaman durante el proceso de prueba. Al seguir esta pista, construye las estadísticas de cobertura de código, que se realiza sobre la marcha durante la segunda ejecución (es decir, generate-report).
- De forma predeterminada, el archivo se crea en cuanto la JVM termina, pero también es posible ejecutar el agente en modo servidor. Esto desencadena un volcado de los resultados y se crea el informe antes de la terminación. A continuación se muestran los internos del plugin JaCoCo:
- Puedes definir objetivos y reglas en la configuración del plugin JaCoCo-Maven. Esto te ofrece la flexibilidad para establecer límites y ayuda a verificar la cantidad de cobertura de código.
- El plugin Maven-surefire es el plugin predeterminado de Maven. Esto ejecuta las pruebas en JVM y proporciona informes de cobertura. Mientras que el plugin JaCoCo instrumenta el código ya ejecutado por un plugin (por ejemplo, el plugin Surefire). Por lo tanto, es una buena práctica verificar la dependencia del plugin maven-surefire.
¿Por qué el plugin JaCoCo-Maven es bueno para la cobertura de código?
El plugin JaCoCo-Maven es adecuado para la cobertura de código debido a las siguientes razones:
- Al trabajar en cualquier proyecto, los desarrolladores suelen preferir IDEs porque simplifican la experiencia de codificación y pruebas. JaCoCo se puede instalar en el IDE de Eclipse bajo el nombre de EclEmma, descargando EclEmma desde su marketplace.
- Es fácil agregar el plugin JaCoCo a todo tipo de builds, incluyendo ANT, Maven y Gradle. También se puede integrar con herramientas de CI/CD como Jenkins, Circle CI, etc. Esto lo hace versátil para muchos casos de uso.
- El informe de cobertura de código generado por JaCoCo es un archivo HTML simple e informativo que se puede ver en cualquier navegador o IDE.
- JaCoCo también ofrece instrumentación fuera de línea (es decir, todas las clases se instrumentan antes de ejecutar cualquier prueba).
- El análisis de un informe también es bastante fácil, ya que es basado en colores y proporciona el porcentaje exacto de cobertura de código.
Cómo configurar el plugin JaCoCo con Maven
Para obtener informes de cobertura de código en un proyecto Maven, primero debemos configurar el plugin JaCoCo para ese proyecto. Al integrar el plugin JaCoCo, los resultados del análisis de cobertura de código se pueden revisar como un informe HTML. La versión actual del plugin JaCoCo-Maven se puede descargar desde el repositorio MVN.
A continuación, se presentan los pasos para integrar el plugin JaCoCo Maven con un proyecto Maven:
1. Cada proyecto de Maven tiene un archivo pom.xml, utilizado para declarar todas las dependencias y plugins. El plugin de JaCoCo-Maven se declara en el mismo archivo POM.xml. El código XML para ello es:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
</plugin>Este es el código XML básico agregado bajo la etiqueta de compilación para especificar el plugin de JaCoCo en un proyecto basado en Maven. Podemos mejorar la funcionalidad (como mencionar cuándo se debe generar un informe, etc.) especificando objetivos y reglas en la etiqueta de ejecución.
2. Después de la etiqueta de versión, agregamos la etiqueta de ejecución. Esta etiqueta prepara las propiedades o ejecución para apuntar al agente de JaCoCo y se pasa como argumento VM (en este caso, JVM).
3. Para ejecutar pruebas unitarias simples, dos objetivos establecidos en etiquetas de ejecución funcionarán bien. Lo mínimo es configurar un objetivo de preparación de agente y objetivos de informe.
<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>- Objetivo de preparación de agente: El objetivo de preparación de agente prepara el agente de tiempo de ejecución de JaCoCo para registrar los datos de ejecución. Registra el número de líneas ejecutadas, rastreadas hacia atrás, etc. Por defecto, los datos de ejecución se escriben en el archivo
target/jacoco-ut.exec. - Objetivo de informe: El objetivo de informe crea informes de cobertura de código a partir de los datos de ejecución registrados por el agente de tiempo de ejecución de JaCoCo. Dado que hemos especificado la propiedad de fase, los informes se crearán después de la compilación de la fase de prueba. Por defecto, los datos de ejecución se leen desde el archivo
target/jacoco-ut.exec, y el informe de cobertura de código se escribe en el directoriotarget/site/jacoco/index.html.
4. Para ejecutar pruebas unitarias simples, la configuración anterior funciona correctamente. Sin embargo, necesitaríamos poner restricciones en los informes de cobertura de código (por ejemplo, especificar el directorio de destino, etc.). Esto se puede hacer mediante una etiqueta de configuración:
<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>Configuración de la Primera Ejecución
Según el código anterior, puedes ver algunas etiquetas, como destFile, etc., están especificadas. Aquí hay una breve descripción de las etiquetas:
destFileetiqueta: La etiquetadestFilese utiliza para establecer la ruta al archivo que contiene los datos de ejecución.propertyName-surefireArgLineetiqueta: Esta etiqueta establece el nombre de la propiedad que contiene la configuración para el agente de tiempo de ejecución de JaCoCo. También establece la línea de argumento de VM cuando se ejecutan las pruebas unitarias.
Configuración de la Segunda Ejecución
Según el código anterior, puedes ver etiquetas como dataFile, etc., están especificadas. Aquí hay una breve descripción de las etiquetas:
dataFileetiqueta: La etiquetadataFilese utiliza para establecer la ruta al archivo que contiene los datos de ejecución.outputDirectoryetiqueta: Esta etiqueta establece el directorio de salida para los informes de cobertura de código.
5. También podemos agregar reglas a nuestra etiqueta de configuración para mantener un control sobre el porcentaje de cobertura de código. Esto se puede hacer como se muestra a continuación:
<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>Configuración de la Tercera Ejecución
Aquí, se define un nuevo objetivo de verificación. El objetivo jacoco:check está vinculado para verificar la regla especificada. La regla se proporciona en la etiqueta de regla. Tienes la flexibilidad de especificar más de una regla.
- Etiqueta de elemento: Esta etiqueta especifica el elemento en el que se debe aplicar la regla.
- Etiqueta de límite: Etiquetas como contador, valor, mínimo, etc., se utilizan para limitar el porcentaje de cobertura de código. Una comanda como mvn clean verify se puede utilizar para asegurarse de si se sigue o no la regla.
6. Se pueden definir múltiples objetivos y reglas en la configuración del complemento JaCoCo-Maven.
Informes de Cobertura de Código Usando Maven y el Plugin JaCoCo
En esta sección, demostraremos los pasos para generar un informe de cobertura de código utilizando el complemento JaCoCo de Maven. La demostración se realiza tomando un escenario de prueba muy simple. Entonces, comencemos.
Requisitos previos
- Maven 3.0 o superior: Maven es una herramienta de desarrollo y comprensión de proyectos. Puedes instalar la versión más reciente desde el sitio web oficial de Apache Maven.
- Java 1.5 o superior: Necesita asegurarse de que Java esté instalado en su máquina. En caso de que no tenga Java instalado, descargue la última versión de Java desde el sitio web oficial de Java.
- Eclipse IDE para Desarrolladores de Java: Aunque puede usar el IDE de su preferencia, para esta demostración hemos utilizado el IDE de Eclipse.
Pasos para Crear un Proyecto Maven Simple
- En el IDE de Eclipse, vaya a Archivo > Nuevo > Proyecto Maven.
2. Aparece una nueva ventana de diálogo. Asegúrate de que la casilla de verificación “Usar ubicación predeterminada del espacio de trabajo” esté marcada y haz clic en “Siguiente.”
3. Para seleccionar el arquetipo en el proyecto, escribe org.apache.maven en el cuadro de texto que se encuentra al lado del filtro. Selecciona maven-archetype-quickstart y haz clic en “Siguiente.”
4. Ahora, especifica el “Group Id” como com.example y el “Artifact Id” como jacoco-example. El “Artifact Id” es el nombre de nuestro proyecto. Finalmente, haz clic en el botón “Finalizar.”
5. Puedes ver la jerarquía de archivos y carpetas del proyecto en “Explorador de proyectos.”
Cómo Especificar el Plugin JaCoCo Maven en POM.xml
1. Abre POM.xml, desplázate hasta la etiqueta. Vamos a especificar el plugin JaCoCo-Maven en la sección que lista los plugins de Maven. Simplemente copia el código a continuación y pégalo en la etiqueta anterior:
<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. Como estamos demostrando la generación de informes para pruebas web automatizadas con JUnit, también declararemos la dependencia de JUnit en POM.xml.
Aquí está todo el contenido 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. Desde el directorio del proyecto, navega hasta el paquete com.example.jacoco_lambdatest existente en src/main/java. Crea una nueva clase Java llamada LambdaTest.java. Escribiremos una simple función setUp() en ella que proporcione las capacidades deseadas 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;
}
}Agregar Casos de Prueba de JUnit en el Proyecto
1. Crearemos un caso de prueba simple de JUnit en AppTest.java. Esto se proporciona por defecto, en la carpeta src/test/java bajo el nombre de paquete 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());
}
}
}Generación de Informes de Cobertura de Código
1. Haz clic en el botón “Run As” y configura la configuración como Maven Test.
2. En su lugar, puedes abrir la línea de comandos (cmd), navegar hasta la carpeta del proyecto y ejecutar el comando maven, “mvn test”.
3. Ejecutar las pruebas de JUnit activará automáticamente el agente JaCoCo. Creará un informe en formato binario en el directorio de destino, con la ruta target/jacoco.exec. La salida de jacoco.exec no puede ser interpretada individualmente, pero otras herramientas como SonarQube y plugins pueden interpretarla. Como especificamos anteriormente, el objetivo jacoco:report generará informes de cobertura de código legibles en formatos populares como HTML, CSV y XML.
4. Una vez que la compilación es exitosa, ve al directorio de destino, luego al sitio > carpeta jacoco. El informe de cobertura de código (es decir, index.html) se encuentra en target/site/jacoco/index.html. El informe se ve así:
5. Puedes profundizar a nivel micro haciendo clic en com.example.jacoco_lambdatest>LambdaTest en el informe.
6. Al hacer clic en funciones específicas, tendrás una vista más detallada en LambdaTest.java.
7. Aquí, verás muchos diamantes de diferentes colores como verde, amarillo y rojo. Estas son las especificaciones utilizadas en el informe para simbolizar qué línea de código se ejecuto y cuándo se ejecuto. Aprenderemos más al respecto en la siguiente sección del análisis del informe. Con esto, has generado con éxito un informe de cobertura de código a través del plugin Jacoco Maven.
Análisis del Informe de Cobertura de Código
Nuestro informe de cobertura de código muestra un 94% de cobertura de instrucciones y un 100% de cobertura de ramas, lo cual es una excelente puntuación de cobertura de código. Más adelante, intentaremos lograr una puntuación de cobertura de código del 100% agregando más casos de prueba.
Las 38 instrucciones mostradas por JaCoCo en el informe se refieren a las instrucciones de bytecode en lugar de las instrucciones de código Java. Los informes de JaCoCo te ayudan a analizar visualmente la cobertura de código utilizando diamantes con colores para las ramas y colores de fondo para resaltar las líneas. Una breve explicación de los diamantes vistos en el informe de cobertura de código es la siguiente:
- Diamante rojo; indica que ninguna rama se ha ejercitado durante la fase de pruebas.
- Diamante amarillo: indica que el código está parcialmente cubierto (es decir, algunas ramas no se han ejercitado).
- Diamante verde: indica que todas las ramas se han ejercitado durante la prueba
El mismo código de color se aplica al color de fondo de resaltado para la cobertura de líneas.
El informe principalmente proporciona tres métricas cruciales:
- Cobertura de líneas: Esto refleja la cantidad de código ejercitado en función del número de instrucciones de código Java byte llamadas por las pruebas.
- Cobertura de ramas: Esto muestra el porcentaje de ramas ejecutadas en el código fuente. Estas son típicas en sentencias if/else o switch.
- Complejidad ciclomática: Esto refleja la complejidad del código a través del número de rutas necesarias para cubrir todos los posibles caminos en un código. También se refiere al número de casos de prueba necesarios para implementar para cubrir todo el código. Como no hay switch ni sentencia en el código, la complejidad ciclomática será uno; solo un camino de ejecución es suficiente para cubrir todo el código.
Introducción de Más Casos de Prueba para Mejorar la Cobertura de Código
1. Para lograr una mejor cobertura de código, se necesitan introducir más pruebas que prueben el código que no fue cubierto previamente a través de la implementación de prueba.
2. Dirígete a AppTest.java en src/test/java para agregar más casos de prueba.
3. Los nuevos casos de prueba agregados a AppTest.java se verán de la siguiente manera:
@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. Ejecutemos el informe de cobertura de Maven JaCoCo para publicar un nuevo informe de cobertura.
5. JaCoCo ofrece una forma simple y fácil de rastrear el puntaje de cobertura de código declarando requisitos mínimos. La compilación falla si estos requisitos no se cumplen, de lo contrario, la compilación es exitosa.
6. Estos requisitos se pueden especificar como reglas en POM.xml. Simplemente especifica la nueva ejecución especificando el objetivo ‘check’ en POM.xml. Agrega el siguiente código después del segundo <execution> tag en 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 esto, estamos limitando nuestra relación de cobertura al 50%. Esto significa que al menos el 50% del código debe estar cubierto durante la fase de prueba.
8. Puedes ejecutar `Maven clean verify` para comprobar si se cumplen las reglas establecidas en el objetivo `jacoco:check`.
9. El registro muestra “Se han cumplido todas las verificaciones de cobertura”, ya que nuestra puntuación de cobertura de código es del 94%, lo cual supera nuestro mínimo del 50%.
Pruebas Automatizadas en la Red Selenium de LambdaTest
Usando Proyecto Maven con el Plugin JaCoCo
Las pruebas de Selenium en la nube te ayudan a lograr una mejor cobertura de navegadores, una mayor cobertura de pruebas y una reducción en el tiempo de lanzamiento al mercado. Pruebas en paralelo en Selenium te permite cumplir con los requisitos mencionados anteriormente.
La Red Selenium de LambdaTest Cloud es una plataforma de pruebas de Selenium escalable en la nube que te permite ejecutar tus scripts de automatización en más de 2000 navegadores y sistemas operativos diferentes.
Requisitos previos
Para ejecutar el script de prueba utilizando JUnit con Selenium, necesitamos configurar un entorno. Primero, deberás crear una cuenta en LambdaTest. Asegúrate de anotar el nombre de usuario y la clave de acceso que están disponibles en la sección de perfil de LambdaTest.
Utilizaremos este proyecto de muestra para pruebas de Selenium en Java.
Importar el Proyecto al IDE de Eclipse
Después de descargar un archivo zip del proyecto: `junit-selenium-sample` desde GitHub, lo importaremos al IDE de Eclipse siguiendo los siguientes pasos:
1. Dirige tu IDE de Eclipse, haz clic en el menú “File” y selecciona “Import.” Aparece una nueva ventana de diálogo.
2. Escribe Maven en el cuadro de texto debajo y selecciona “Existing Maven Projects,” y luego haz clic en “Next.”
3. En la siguiente ventana de diálogo, haz clic en “Browse” y navega hasta la carpeta del proyecto. Además, marca la casilla que proporciona la ruta al archivo POM.xml, y haz clic en “Finish.”
4. Tu proyecto se cargará correctamente en el IDE de Eclipse.
Añadiendo Dependencias en el Archivo POM.xml
1. Abre el POM.xml, ahora añade las dependencias de JUnit, Selenium, y JaCoCo Maven Plugin. Después de añadir las dependencias, el código de POM.xml debería verse así:
<?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>Configurando las Capacidades Deseadas para las Pruebas Automatizadas de JUnit
1. Para conectarse a la Red de Automatización Selenium de LambdaTest, lo primero que se hace es invocar un webdriver remoto. Este conductor remoto requiere ciertas capacidades como el navegador, versiones del navegador, sistema operativo, etc., para construir un entorno. El código para ello se ve de la siguiente manera:
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. En el código de pruebas automatizadas de JUnit, las capacidades como el navegador, versiones del navegador, información del sistema operativo, etc., pueden ser personalizadas y se pasan a través del objeto de capacidades.
3. LambdaTest ha facilitado este proceso al proporcionar un generador de capacidades incorporado. El generador de capacidades generará automáticamente el código para las capacidades deseadas en función de tus entradas. Por ejemplo, nuestras configuraciones son:
|
Campos |
Valores Seleccionados |
|
Sistemas Operativos |
Windows 10 |
|
Navegador |
Chrome |
|
Versión del Navegador |
62.0 |
|
Resolución |
1024×768 |
|
Versión de Selenium |
3.13.0 |
4. Seleccionar la configuración especificada anteriormente en el generador de capacidades y pegarla en LambdaTestBaseTest.java.
Especificar el Nombre de Usuario y la Clave de Acceso de LambdaTest en la Clase Java Requerida
1. En el Explorador de Proyectos, verás tres clases Java:
LambdaTestBaseTest.java (contiene la configuración necesaria para las pruebas de Selenium en Java).Parallelized.java(contiene pruebas Junit para pruebas en paralelo en la red Selenium de LambdaTest).SimpleTest.java(contiene pruebas unitarias simples).
2. LambdaTestBaseTest.java obtiene los datos requeridos como capacidades deseadas, nombre de usuario y clave de acceso de un archivo de configuración. Esto se proporciona en src/test/resources como config.json.
3. Especifica las capacidades deseadas, el nombre de usuario y la clave de acceso en config.json. Este archivo JSON se utiliza ya que puedes proporcionar múltiples configuraciones en él para realizar pruebas en paralelo con Selenium especificando múltiples configuraciones en config.json y luego obtenerlas más tarde.
[ { "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" }]Pruebas Unitarias Usando JUnit con Selenium:
1. SimpleTest.java es la clase Java para especificar un caso de prueba unitario único para pruebas y realizar cobertura de código utilizando el 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. Este es un simple test de Selenium WebDriver que abrirá una aplicación de muestra para hacer las siguientes tareas:
- Marcar los dos primeros elementos como “Hecho.”
- Agregar un nuevo elemento a la lista.
- Devolver el elemento agregado.
3. Disparar el comando mvn test en la terminal para compilar y ejecutar el caso de prueba.
4. Ahora, inicie sesión en su cuenta de LambdaTest y vaya a “Automatización.” Encontrará las pruebas que ejecuto bajo el nombre de compilación “Pruebas JUnit JaCoCo.”
5. Haga clic en “Pruebas JUnit JaCoCo” y revise detalladamente. LambdaTest ha grabado el video. Entonces puedes ver las imágenes también.
Generando Informe de Cobertura de Código a través del Plugin JaCoCo Maven:
- Ahora, como hemos ejecutado los casos de prueba JUnit en la Red Selenium de LambdaTest, el informe de cobertura de código debería generarse a través del plugin JaCoCo Maven.
- Simplemente vaya al directorio de destino, y encontrará el formato binario del informe como
jacoco.exec. - Puedes ver el formato HTML, CSV y XML del informe de cobertura de código en el directorio
target/site/jacococomoindex.html, jacoco.csv, yjacoco.xml, respectivamente. - Ahora también puedes intentar mejorar el puntaje de cobertura de código y analizar el informe de cobertura de código generado.
Conclusión
En este artículo, hemos visto cómo utilizar el plugin JaCoCo-Maven para generar informes de cobertura de código para proyectos Java. También hemos aprovechado la agilidad y escalabilidad de LambdaTest Selenium Grid cloud para automatizar los procesos de prueba. Recuerda, sin embargo, que el 100% de cobertura de código no es responsable de reflejar una prueba efectiva, ya que solo muestra la cantidad de código ejercitado durante las pruebas.
Aún así, ayuda a reducir el número de errores e impulsa la calidad de los lanzamientos de software. Además, agrega una sobrecarga mínima al proceso de compilación y permite mantener un cierto umbral a medida que el equipo de desarrollo añade casos límite o implementa programación defensiva.
Source:
https://dzone.com/articles/how-to-generate-code-coverage-report-jacoco-maven