Pruebas unitarias y TDD con NodeJS y Mocha (Parte 2). Un caso práctico

En el post anterior (te dejo aquí el link), vimos algunos conceptos sobre esta manera de trabajar, TDD. En el post de hoy vamos a ir a la práctica, vamos a ver un caso práctico, muy sencillo, usando estos frameworks.
Primero vamos a escribir nuestro caso de test con Mocha y luego implementar el código que tiene que pasar el test en NodeJS. Por último ejecutaremos Mocha para ver si nuestro código pasa la prueba, así que, vamos a ello:

Definiendo el caso de test

Para empezar el caso de test, vamos a crear dentro de una carpeta test (dentro de nuestro proyecto raíz) un archivo que vamos a llamar first_test.js (por convención los test los vamos a terminar con _test.js para diferenciarlo del código). Empezamos creando la descripción del caso usando las sentencias describe e it  como vimos en el ejemplo del post anterior.
describe” es una función que acepta dos parámetros:

  • El Primero es un string que describe la principal acción del test. En este caso es: maybeFirst (ahora lo vemos con más detalle).
  • El segundo es una función en la que tenemos que escribir qué es lo que ha de hacer el test.

La sentencia it se trata de una función que, al igual que describe, también acepta dos parámetros:

  • El primero es un string con la descripción exacta de lo que haremos (podemos decir que el nombre de nuestro test).
  • La segunda es otra función que contiene el test definido en expect (expect es una librería de aserciones que nos permite redactar test. Si queréis ver un listado completo de todo lo que podemos hacer con expect os recomiendo visitar la documentación del API en su repo).

Una vez explicado esto, el ejemplo que vamos a usar es el siguiente:

Caso prueba con mocha
Caso de prueba con Mocha

Resumidamente… nuestro caso de test va a llamar a la función maybeFirst con el array  [1,2,3]. Esta función va a retornar el primer elemento, y para comprobar que realmente es el primer elemento, en este caso 1 de nuestro array, lo vamos a comparar con 1. Si es así, pasaremos el caso de prueba, si no es así estará retornado otra posición.
Explicado más detalladamente…
En la variable result almacenamos lo que nos devuelve la función maybeFirst (el primer elemento de un array). Con la sentencia assert.equal, vamos a comparar si el valor de la variable result es 1, puesto que así lo hemos decidido declarando nuestro array como [1,2,3], y este 1 será el segundo parámetro en la sentencia asser.equal.
Como decía antes, si la función maybeFirst nos devuelve 1, al compararlo con 1, sabremos que nos devuelve la posición 1, puesto que el caso de prueba pasará, en caso contrario será un caso fallido.
Otras sentencias que hay que añadir al principio de este archivo son require assert, para poder hacer afirmaciones y el espacio de nombres UnitTestingFramework para comprobar una funcionalidad específica, como os comentaba en el primer post y también necesitaremos  require(‘../src/first’) para indicar dónde vamos a tener el código a testear (ahora lo veremos, pero first será nuestro archivo donde implementaremos la función en NodeJS).

Escribiendo el código a testear

Una vez que tenemos definido el test con lo que ha de hacer nuestra aplicación empezamos a crear el código que permita pasar ese test. Esta es la base del TDD. Es importante destacar que primero escribimos el test y luego el código que lo pasa.
Comenzamos creando un archivo en la carpeta src (creada dentro de nuestro proyecto raíz) llamado first.js. Este archivo contendrá el código que pase la prueba que hicimos antes.

Lugar del archivo first.js donde implementaremos nuestro código
Lugar del archivo first.js donde implementaremos nuestro código

Nota: la carpeta node_modules se creará al instalar nodeJS y el archivo package.json al inicializar un paquete de node mediante el comando $ npm init.
En este archivo vamos a escribir la función de la que tenemos obtener el primer elemento de un array como os muestro en la siguiente imagen.
Código a testear
Código a testear

Con la sentencia module.export exportamos la función para que sea accesible, retornamos el primer elemento del array (creo que el código es demasiado trivial como para entrar más en él :P), y con esto ya estaría.

Ejecutando la prueba con Mocha

Una vez que tenemos el código que pase la prueba implementado, procedemos a ejecutar la prueba. Para ello mediante línea de comando ejecutamos simplemente $ mocha, y con ello estaría, lo vemos en la siguiente imagen (puedes ver que lo que escribimos en el modulo it, el nombre del caso de test es lo que nos muestra en la consola):

Caso de prueba pasado
Caso de prueba pasado

Para mostrar ese mismo ejemplo como un caso de fallo, imaginaos que en nuestro archivo first.js (en la carpeta src) en vez de devolver la posición 0 que es lo que hacemos en este ejemplo, cambiamos el 0 por el 1 (de esta manera retornamos el segundo elemento del array), como se muestra en la siguiente imagen:
Código a testear caso de fallo
Código a testear (Caso de fallo)

Si volvemos a ejecutar $ mocha veremos como nos falla y se nos muestra de manera similar al log de un IDE (lo puedes ver en la siguiente imagen):
Caso de prueba fallido
Caso de prueba fallido

Los informes en Mocha

En el primer post, vimos que una de las características de Mocha eran los informes, con Mocha podemos mostrar los resultados en diferentes formatos (dependiendo del número de pruebas puede interesarnos unos u otros), en consola, en un navegador web, en la consola JS de un navegador web, generando un archivo JSON, etc.. Mocha usa por defecto la salida por terminal con el formato spec como se muestra en la ejecución de mocha del ejemplo anterior.
Para probar esto simplemente tienes que añadir en un archivo package.json por defecto que se nos crea al ejecutar el comando $ npm init la sentencia:
«scripts»: {
   «test»: «mocha –compilers js:babel/register –reporter nyan»
 },
La siguiente imagen es un ejemplo del archivo package.json:

Archivo package.json
Archivo package.json

Y hasta aquí la serie de post sobre TDD con NodeJS y Mocha, espero que os sirva de ayuda para seguir investigando sobre ello y profundizar más o para conocer nuevas tecnologías que a lo mejor las puedes usar para algo.

jgarzas

Ph.D. en informática, Postdoctorado en la Carnegie Mellon (EE.UU) e Ingeniero en Informática.

Primera vez que me tocó hacer una gestión Ágil en una empresa... año 2001. Desde entonces he trabajado en, o para, más de 90. Y he formado a más de 2000 alumnos.

También soy profe de la Universidad Rey Juan Carlos.

0 comentarios en “Pruebas unitarias y TDD con NodeJS y Mocha (Parte 2). Un caso práctico”

  1. Hola María
    Si bien explicas claramente el tema, quisiera saber si existe algún tutorial mas profundo.
    Me explico, supongamos que quiero hacer test de un login, de modo tal de pasar «n» posibles casos y que descubra algún error no contemplado.
    Gracias

Dejar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *