Cobertura de las pruebas unitarias en JavaScript (Creación de una librería JavaScript 5ª parte)

Medir la cobertura de las pruebas unitarias en JavaScript es clave para garantizar que se está probando todo el código. Esto es lo que se explicará en la quinta entrega de la serie en la que se enseña a crear una librería JavaScript.

Esta entrada pertenece a la serie “Creación de una librería JavaScript” cuyo código se puede encontrar en la cuenta de GitHub de Analytics Lane. Serie compuesta por las siguientes entradas:

• Creación de una librería JavaScript
• Estructurar las funciones JavaScript
• Pruebas unitarias en JavaScript
• Rango en pruebas unitarias en JavaScript
• Cobertura de las pruebas unitarias en JavaScript
• Medir la calidad del código JavaScript
• Compresión del código JavaScript
• Ejecutar múltiples scripts npm

Instalación de los módulos

Para medir y probar la cobertura de las pruebas unitarias una de las herramientas más poderosas es Istanbul. La forma más rápida de probar esto en node es importando el módulo ncy, que es la interfaz de línea de comandos de Istanbul. La instalación del módulo se realiza con npm como en el resto de los casos.

npm install nyc --save-dev

Una vez ejecutada esta línea se instalará el paquete y se agregará a la lista de dependencias.

Ejecutar las pruebas unitarias con Istanbul

En primer lugar, es necesario ejecutar las pruebas unitarias con Istanbul para poder obtener un informe de cobertura. La forma más fácil de hacer esto es con la siguiente línea de código.

nyc npm test

Así se ejecutará el script con las pruebas unitarias obteniéndose el siguiente informe.

------------|----------|----------|----------|----------|-------------------|
File        |  % Stmts | % Branch |  % Funcs |  % Lines | Uncovered Line #s |
------------|----------|----------|----------|----------|-------------------|
All files   |    95.45 |       50 |      100 |    95.45 |                   |
 jslane     |      100 |      100 |      100 |      100 |                   |
  index.js  |      100 |      100 |      100 |      100 |                   |
 jslane/lib |    95.24 |       50 |      100 |    95.24 |                   |
  array.js  |    94.44 |       50 |      100 |    94.44 |                35 |
  jslane.js |      100 |      100 |      100 |      100 |                   |
------------|----------|----------|----------|----------|-------------------|

En este se puede ver que la línea 35 del archivo array.js no se ejecuta en las pruebas unitarias. Lo que significa el nivel de cobertura de todo el proyecto a nivel de líneas es del 95,45%, el 100% de las funciones y el 50% de las ramas.

Este informe no es fácil de interpretar cuando el proyecto crece. El número de líneas sin cobertura puede ser tal que únicamente se puedan mostrar una pocas. El informe se puede modificar con la opción --reporter, pudiendo exportar este en un archivo HTML con la opción lcov. Así el siguiente comando creará una carpeta lcov-report con el informe navegable.

nyc --reporter=lcov npm test

Al abrir el informe en el navegador se observa la siguiente

Pudiéndose comprobar las líneas que no se prueban en durante las pruebas unitarias.

Comprobando el grado de cobertura

ncy permite probar el grado de cobertura de las pruebas unitarias. En caso de que no se alcance un mínimo las prueba fallará. Para ello se puede ejecutar el siguiente comando después de haber lanzado las pruebas con Istanbul.

nyc check-coverage --lines 95 --functions 95 --branches 95

En este ejemplo se pide que el nivel de cobertura sea como mínimo del 95% a nivel de línea, funciones y ramas. Si una sola de las métricas en inferior se producirá un error. Revisando el informe anterior se puede ver que a nivel de rama no se llega al mínimo indicado.

Mejorado el grado de cobertura

Para superar el grado de cobertura simplemente es necesario escribir una prueba que evalúe la función multiply sin segundo parámetro. Lo que se puede conseguir con la siguiente aserción.

expect(jslane.array.multiply([1, 1, 1])).to.deep.equal([1, 1, 1]);

Si ahora se ejecuta el comando nyc npm test se puede observar que el nivel de cobertura es ahora del 100%. Por lo tanto, las pruebas de cobertura anteriores se superarán en este caso.

------------|----------|----------|----------|----------|-------------------|
File        |  % Stmts | % Branch |  % Funcs |  % Lines | Uncovered Line #s |
------------|----------|----------|----------|----------|-------------------|
All files   |      100 |      100 |      100 |      100 |                   |
 jslane     |      100 |      100 |      100 |      100 |                   |
  index.js  |      100 |      100 |      100 |      100 |                   |
 jslane/lib |      100 |      100 |      100 |      100 |                   |
  array.js  |      100 |      100 |      100 |      100 |                   |
  jslane.js |      100 |      100 |      100 |      100 |                   |
------------|----------|----------|----------|----------|-------------------|

Creación de nuevos scripts

Conocer el grado de cobertura de las pruebas es importante a la hora de medir la calidad del código. Por eso es aconsejable crear dos nuevos scripts en el archivo pasckage.json con los que se puede automatizar estas tareas. Uno de ellos puede ser coverage en el que ejecutan las pruebas unitarias con ncy, es decir, lanzar el comando nyc --reporter=lcov npm test. El segundo se puede denominar checkCoverage, en el que puede comprobar si se alcanza un mínimo de cobertura con el comando nyc check-coverage --lines 95 --functions 95 --branches 95

Conclusiones

En esta quinta entrega se ha visto cómo medir la cobertura de las pruebas unitarias en JavaScript. Otro punto importante a la hora de medir la calidad del código.