Pruebas Unitarias Parte 4: Code coverage con JaCoCo


En posts anteriores hemos hablado sobre como escribir nuestros test unitarios, el uso de mocks, spying y como escribir código “Testeable”, el día de hoy hablaremos sobre un concepto llamado Code coverage.

Code Coverage

El code coverage es una métrica utilizada en el desarrollo de software que determina el número de líneas de código que fueron ejecutadas durante nuestros test unitarios. Utilizando code coverage podemos determinar si nuestras aplicaciones se prueban de forma correcta y que porcentaje de escenarios no cuenta con pruebas automatizadas.

JaCoCo

JaCoCo es un plugin de maven que se utiliza para realizar reportes con base en la métrica de code coverage.

Configuración

Para configurar JaCoCo solo debemos incluir el siguiente plugin en nuestro código

<plugin>
	<groupId>org.jacoco</groupId>
	<artifactId>jacoco-maven-plugin</artifactId>
	<version>0.8.2</version>
	<executions>
		<execution>
			<goals>
				<goal>prepare-agent</goal>
			</goals>
		</execution>
		<execution>
			<id>report</id>
			<phase>prepare-package</phase>
			<goals>
				<goal>report</goal>
			</goals>
		</execution>
	</executions>
</plugin>

Utilizaremos JUnit para hacer nuestros tests de ejemplo así que incluiremos su dependencia a nuestro proyecto:

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.10</version>
	<scope>test</scope>
</dependency>

Con lo anterior tenemos listo nuestro ambiente para empezar a trabajar con JaCoCo y JUnit.

Paso 2 : Creando una clase de ejemplo 

Una vez que tenemos nuestro ambiente listo, crearemos una clase sobre la que ejecutaremos nuestras pruebas:

/**
 * @author raidentrance
 *
 */
public class Calculator {
	public int sumPositiveValues(int... numbers) {
		int sum = 0;
		for (int number : numbers) {
			if(number>0){
				sum += number;
			}
		}
		return sum;
	}
}

La clase Calculator tiene un método llamado sumPositiveValues(…) el cual dado un conjunto de números enteros sumará todos aquellos que sean positivos.

Paso 3 : Creando test unitarios

Una vez que tenemos nuestro método a probar el siguiente paso será crear su test unitario, veamos el ejemplo:

import static org.junit.Assert.assertTrue;

import org.junit.Test;

/**
 * @author raidentrance
 *
 */
public class CalculatorTest {
	private Calculator calculator = new Calculator();

	@Test
	public void testSumPositiveValues_withNegativeValues() {
		int result = calculator.sumPositiveValues(-10, -20, -30);
		assertTrue(result == 0);
	}
}

Como podemos ver el test unitario prueba el método sumPositiveValues() solo con valores negativos y al final valida que el resultado sea cero, si ejecutamos lo anterior veremos que el test unitario es exitoso.

Paso 4 : Ejecutando el goal de JaCoCo

Una vez que tenemos nuestro test listo queremos ver el code coverage de nuestro programa, para esto ejecutaremos el siguiente goal de maven:

mvn install
mvn jacoco:report

El goal anterior creará un directorio dentro de el directorio target llamado site dentro de este veremos otro folder llamado jacoco y dentro de el un archivo llamado index.html que al abrirlo se verá como se muestra a continuación:

El reporte anterior indica que el code coverage de nuestra aplicación es de 86%, todo nuestro código se encuentra dentro del paquete com.devs4j.jacoco , al darle click veremos la clase Calculator y su porcentaje de code coverage como se muestra en la siguiente imagen:

Al dar click en Calculator podremos ver el code coverage a nivel de método:

En este caso podemos ver que el método sumPositiveValues tiene un 84% de code coverage, al darle click podemos ver exactamente el código que no se ejecutó durante los tests:

En este caso podemos ver que como el test unitario solo probó el resultado utilizando números negativos la línea 15 nunca se ejecutó. Por esta razón no alcanzamos un code coverage de 100%.

Paso 5 : Agregando los tests faltantes

Como vimos una parte de nuestro código no se ejecutó durante los tests, eso significa que debemos agregar un test que utilice números positivos para asegurarnos que todo nuestro código se ejecutó durante la fase de tests unitarios, para esto modificaremos la clase CalculatorTest.java y agregaremos el siguiente test:

@Test
public void testSumPositiveValues_withPositiveValues() {
	int result = calculator.sumPositiveValues(10, 20, 30);
	assertTrue(result == 60);
}

Una vez hecho esto aseguraremos que con los dos tests unitarios que tenemos se ejecutará todo nuestro código.

Paso 6: Ejecutando de nuevo JaCoCo

Una vez incluido el nuevo test ejecutaremos nuevamente el plugin de JaCoCo para ver el nuevo code coverage:

Como podemos ver ahora el code coverage de nuestra aplicación es del 100%, esto no nos asegura que nuestro código es perfecto, pero si que todas las partes de el fueron probadas por tests unitarios.

Puedes encontrar el código completo en el siguiente enlace : https://github.com/raidentrance/jacoco-example.

Para estar al pendiente sobre nuestro contenido nuevo síguenos en nuestras redes sociales  https://www.facebook.com/devs4j/ y https://twitter.com/devs4j.

Autor: Alejandro Agapito Bautista

Twitter: @raidentrance

Contacto:raidentrance@gmail.com

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión /  Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión /  Cambiar )

Conectando a %s